4 * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
6 * Contact: Hocheol Seo <hocheol.seo@samsung.com>
7 * Girishashok Joshi <girish.joshi@samsung.com>
8 * Chanyeol Park <chanyeol.park@samsung.com>
10 * Licensed under the Apache License, Version 2.0 (the "License");
11 * you may not use this file except in compliance with the License.
12 * You may obtain a copy of the License at
14 * http://www.apache.org/licenses/LICENSE-2.0
16 * Unless required by applicable law or agreed to in writing, software
17 * distributed under the License is distributed on an "AS IS" BASIS,
18 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
19 * See the License for the specific language governing permissions and
20 * limitations under the License.
24 #include <dbus/dbus-glib.h>
25 #include <dbus/dbus-glib-lowlevel.h>
26 #include <dbus/dbus.h>
31 #include <vconf-internal-bt-keys.h>
32 //#include <journal/device.h>
34 #include "bluetooth-api.h"
35 #include "bt-internal-types.h"
37 #include "bt-service-common.h"
38 #include "bt-service-event.h"
39 #include "bt-service-main.h"
40 #include "bt-service-adapter.h"
41 #include "bt-service-adapter-le.h"
42 #include "bt-service-device.h"
43 #include "bt-service-avrcp.h"
44 #include "bt-service-obex-server.h"
45 #include "bt-service-rfcomm-server.h"
46 #include "bt-service-audio.h"
47 #include "bt-service-agent.h"
48 #include "bt-service-pbap.h"
49 #include "bt-service-headset-connection.h"
50 #include "bt-service-opp-client.h"
52 static DBusGConnection *manager_conn;
53 static DBusGConnection *obexd_conn;
54 static GList *p_cache_list = NULL;
55 static DBusGConnection *opc_obexd_conn = NULL;
58 static guint event_id;
59 guint nap_connected_device_count = 0;
60 static guint hid_connected_device_count = 0;
61 static GList *p_adv_ind_list;
70 bt_remote_dev_info_t *dev_info;
74 * obexd connection type
82 OBEX_PCSUITE = (1 << 6),
83 OBEX_SYNCEVOLUTION = (1 << 7),
85 } bluetooth_obex_connection_type_t;
87 void _bt_handle_property_changed_event(DBusMessage *msg);
88 void _bt_opc_property_changed_event(DBusMessage *msg);
89 int _bt_register_service_event(DBusGConnection *g_conn, int event_type);
90 void _bt_unregister_service_event(DBusGConnection *g_conn, int event_type);
91 void _bt_opp_client_event_deinit(void);
93 static void __bt_free_bt_le_adv_info_t(bt_le_adv_info_t *adv_info)
95 g_free(adv_info->addr);
96 g_free(adv_info->data);
100 static bt_le_adv_info_t *__bt_get_adv_ind_info(char *addr)
102 retv_if(!addr, NULL);
103 bt_le_adv_info_t *adv_info = NULL;
104 GList *current = g_list_first((GList *)p_adv_ind_list);
105 while(current && current->data) {
106 adv_info = (bt_le_adv_info_t *)current->data;
107 retv_if(adv_info && !g_strcmp0(adv_info->addr, addr), adv_info);
108 current = g_list_next(current);
113 static void __bt_add_adv_ind_info(bt_le_adv_info_t *adv_info)
116 if (__bt_get_adv_ind_info(adv_info->addr) != NULL) {
117 BT_ERR("adv_info is already added");
118 __bt_free_bt_le_adv_info_t(adv_info);
121 p_adv_ind_list = g_list_append(p_adv_ind_list, adv_info);
124 static void __bt_del_adv_ind_info(char *addr)
127 ret_if(!p_adv_ind_list);
128 bt_le_adv_info_t *adv_info = NULL;
129 GList *current = g_list_first((GList *)p_adv_ind_list);
130 while(current && current->data) {
131 adv_info = (bt_le_adv_info_t *)current->data;
132 if (adv_info && !g_strcmp0(adv_info->addr, addr)) {
133 p_adv_ind_list = g_list_remove(p_adv_ind_list, adv_info);
134 __bt_free_bt_le_adv_info_t(adv_info);
137 current = g_list_next(current);
141 static void __bt_free_cache_info(bt_cache_info_t *cache_info)
143 ret_if(cache_info == NULL);
145 _bt_free_device_info(cache_info->dev_info);
149 static gboolean __bt_parse_device_properties(DBusMessageIter *item_iter,
150 bt_remote_dev_info_t *dev_info)
153 DBusMessageIter value_iter;
156 dbus_message_iter_recurse(item_iter, &value_iter);
158 if (dbus_message_iter_get_arg_type(&value_iter) != DBUS_TYPE_DICT_ENTRY) {
163 while (dbus_message_iter_get_arg_type(&value_iter) ==
164 DBUS_TYPE_DICT_ENTRY) {
166 DBusMessageIter dict_entry;
167 DBusMessageIter iter_dict_val;
169 dbus_message_iter_recurse(&value_iter, &dict_entry);
171 dbus_message_iter_get_basic(&dict_entry, &key);
174 dbus_message_iter_next(&value_iter);
178 if (!dbus_message_iter_next(&dict_entry)) {
179 dbus_message_iter_next(&value_iter);
182 dbus_message_iter_recurse(&dict_entry, &iter_dict_val);
185 if (strcasecmp(key, "Address") == 0) {
186 const char *address = NULL;
187 dbus_message_iter_get_basic(&iter_dict_val, &address);
188 dev_info->address = g_strdup(address);
189 } else if (strcasecmp(key, "Class") == 0) {
190 dbus_message_iter_get_basic(&iter_dict_val, &dev_info->class);
191 } else if (strcasecmp(key, "name") == 0) {
192 dbus_message_iter_get_basic(&iter_dict_val, &value);
193 if (dev_info->name == NULL)
194 dev_info->name = g_strdup(value);
195 } else if (strcasecmp(key, "Connected") == 0) {
196 dbus_message_iter_get_basic(&iter_dict_val,
197 &dev_info->connected);
198 } else if (strcasecmp(key, "paired") == 0) {
199 dbus_message_iter_get_basic(&iter_dict_val,
201 } else if (strcasecmp(key, "Trusted") == 0) {
202 dbus_message_iter_get_basic(&iter_dict_val,
204 } else if (strcasecmp(key, "RSSI") == 0) {
205 dbus_message_iter_get_basic(&iter_dict_val,
207 } else if (strcasecmp(key, "LastAddrType") == 0) {
208 dbus_message_iter_get_basic(&iter_dict_val,
209 &dev_info->addr_type);
210 } else if (strcasecmp(key, "UUIDs") == 0) {
211 DBusMessageIter uuid_iter;
212 DBusMessageIter tmp_iter;
215 dbus_message_iter_recurse(&iter_dict_val, &uuid_iter);
217 tmp_iter = uuid_iter;
219 /* Store the uuid count */
220 while (dbus_message_iter_get_arg_type(&tmp_iter) != DBUS_TYPE_INVALID) {
221 dbus_message_iter_get_basic(&tmp_iter,
224 dev_info->uuid_count++;
225 if (!dbus_message_iter_next(&tmp_iter))
229 /* Store the uuids */
230 if (dev_info->uuid_count > 0) {
231 dev_info->uuids = g_new0(char *,
232 dev_info->uuid_count + 1);
234 dbus_message_iter_next(&value_iter);
238 while (dbus_message_iter_get_arg_type(&uuid_iter) != DBUS_TYPE_INVALID) {
239 dbus_message_iter_get_basic(&uuid_iter,
241 dev_info->uuids[i] = g_strdup(value);
243 if (!dbus_message_iter_next(&uuid_iter)) {
247 } else if (strcasecmp(key, "ManufacturerDataLen") == 0) {
248 dbus_message_iter_get_basic(&iter_dict_val,
249 &dev_info->manufacturer_data_len);
251 if (dev_info->manufacturer_data_len > BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX) {
252 BT_ERR("manufacturer_data_len is too long(len = %d)", dev_info->manufacturer_data_len);
253 dev_info->manufacturer_data_len = BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX;
256 if (dev_info->manufacturer_data_len == 0)
257 dev_info->manufacturer_data = g_strdup("");
258 } else if (strcasecmp(key, "ManufacturerData") == 0) {
259 DBusMessageIter manufacturer_iter;
262 char *manufacturer_data = NULL;
265 dbus_message_iter_recurse(&iter_dict_val, &manufacturer_iter);
266 len = dbus_message_iter_get_array_len(&manufacturer_iter);
268 dev_info->manufacturer_data = g_malloc0(len);
269 manufacturer_data = dev_info->manufacturer_data;
271 while (dbus_message_iter_get_arg_type(&manufacturer_iter) == DBUS_TYPE_BYTE) {
272 dbus_message_iter_get_basic(&manufacturer_iter, &byte);
273 manufacturer_data[i] = byte;
275 dbus_message_iter_next(&manufacturer_iter);
280 dbus_message_iter_next(&value_iter);
287 static gboolean __bt_parse_interface(DBusMessage *msg,
288 bt_remote_dev_info_t *dev_info)
292 DBusMessageIter msg_iter;
293 DBusMessageIter value_iter;
294 char *object_path = NULL;
296 retv_if(dbus_message_iter_init(msg, &msg_iter) == FALSE, FALSE);
298 dbus_message_iter_get_basic(&msg_iter, &object_path);
299 retv_if(object_path == NULL, FALSE);
301 /* object array (oa) */
302 retv_if(dbus_message_iter_next(&msg_iter) == FALSE, FALSE);
303 retv_if(dbus_message_iter_get_arg_type(&msg_iter) !=
304 DBUS_TYPE_ARRAY, FALSE);
306 dbus_message_iter_recurse(&msg_iter, &value_iter);
308 /* string array (sa) */
309 while (dbus_message_iter_get_arg_type(&value_iter) ==
310 DBUS_TYPE_DICT_ENTRY) {
311 char *interface_name = NULL;
312 DBusMessageIter interface_iter;
314 dbus_message_iter_recurse(&value_iter, &interface_iter);
316 retv_if(dbus_message_iter_get_arg_type(&interface_iter) !=
317 DBUS_TYPE_STRING, FALSE);
319 dbus_message_iter_get_basic(&interface_iter, &interface_name);
321 retv_if(dbus_message_iter_next(&interface_iter) == FALSE, FALSE);
323 retv_if(dbus_message_iter_get_arg_type(&interface_iter) !=
324 DBUS_TYPE_ARRAY, FALSE);
326 BT_DBG("interface: %s", interface_name);
328 if (g_strcmp0(interface_name, "org.bluez.Device1") == 0) {
329 BT_DBG("Found a device: %s", object_path);
331 if (__bt_parse_device_properties(&interface_iter,
332 dev_info) == FALSE) {
333 BT_ERR("Fail to parse the properies");
340 dbus_message_iter_next(&value_iter);
348 char *__bt_get_headset_name(char *address)
350 bluetooth_device_address_t device_address = { {0} };
351 bluetooth_device_info_t dev_info;
353 retv_if(address == NULL, strdup(""));
355 _bt_convert_addr_string_to_type(device_address.addr, address);
357 memset(&dev_info, 0x00, sizeof(bluetooth_device_info_t));
359 _bt_get_bonded_device_info(&device_address, &dev_info);
361 return g_strdup(dev_info.device_name.name);
364 static int __bt_get_owner_info(DBusMessage *msg, char **name,
365 char **previous, char **current)
367 DBusMessageIter item_iter;
369 dbus_message_iter_init(msg, &item_iter);
371 if (dbus_message_iter_get_arg_type(&item_iter)
372 != DBUS_TYPE_STRING) {
373 BT_ERR("This is bad format dbus");
374 return BLUETOOTH_ERROR_INTERNAL;
377 dbus_message_iter_get_basic(&item_iter, name);
379 retv_if(*name == NULL, BLUETOOTH_ERROR_INTERNAL);
381 dbus_message_iter_next(&item_iter);
383 if (dbus_message_iter_get_arg_type(&item_iter)
384 != DBUS_TYPE_STRING) {
385 BT_ERR("This is bad format dbus");
386 return BLUETOOTH_ERROR_INTERNAL;
389 dbus_message_iter_get_basic(&item_iter, previous);
391 retv_if(*previous == NULL, BLUETOOTH_ERROR_INTERNAL);
393 dbus_message_iter_next(&item_iter);
395 if (dbus_message_iter_get_arg_type(&item_iter)
396 != DBUS_TYPE_STRING) {
397 BT_ERR("This is bad format dbus");
398 return BLUETOOTH_ERROR_INTERNAL;
401 dbus_message_iter_get_basic(&item_iter, current);
403 retv_if(*current == NULL, BLUETOOTH_ERROR_INTERNAL);
405 return BLUETOOTH_ERROR_NONE;
408 static int __bt_get_agent_signal_info(DBusMessage *msg, char **address,
409 char **name, char **uuid)
413 DBusMessageIter item_iter;
415 dbus_message_iter_init(msg, &item_iter);
417 if (dbus_message_iter_get_arg_type(&item_iter)
418 != DBUS_TYPE_STRING) {
419 BT_ERR("This is bad format dbus");
420 return BLUETOOTH_ERROR_INTERNAL;
423 dbus_message_iter_get_basic(&item_iter, address);
425 dbus_message_iter_next(&item_iter);
427 if (dbus_message_iter_get_arg_type(&item_iter)
428 != DBUS_TYPE_STRING) {
429 BT_ERR("This is bad format dbus");
430 return BLUETOOTH_ERROR_INTERNAL;
433 dbus_message_iter_get_basic(&item_iter, name);
435 dbus_message_iter_next(&item_iter);
437 if (dbus_message_iter_get_arg_type(&item_iter)
438 != DBUS_TYPE_STRING) {
439 BT_ERR("This is bad format dbus");
440 return BLUETOOTH_ERROR_INTERNAL;
443 dbus_message_iter_get_basic(&item_iter, uuid);
447 return BLUETOOTH_ERROR_NONE;
450 void __bt_set_device_values(gboolean connected, int state)
452 int bt_device_state = VCONFKEY_BT_DEVICE_NONE;
454 if (vconf_get_int(VCONFKEY_BT_DEVICE, &bt_device_state) != 0) {
455 BT_ERR("vconf_get_int failed");
458 if (connected == TRUE)
459 bt_device_state |= state;
460 else if (bt_device_state & state)
461 bt_device_state ^= state;
463 if (vconf_set_int(VCONFKEY_BT_DEVICE, bt_device_state) != 0) {
464 BT_ERR("vconf_set_int failed");
468 gboolean _bt_discovery_finished_cb(gpointer user_data)
470 int result = BLUETOOTH_ERROR_NONE;
473 if (_bt_get_discovering_property(DISCOVERY_ROLE_BREDR) == FALSE) {
474 if (_bt_get_cancel_by_user() == TRUE) {
475 result = BLUETOOTH_ERROR_CANCEL_BY_USER;
478 _bt_set_cancel_by_user(FALSE);
479 _bt_set_discovery_status(FALSE);
480 _bt_send_event(BT_ADAPTER_EVENT,
481 BLUETOOTH_EVENT_DISCOVERY_FINISHED,
482 DBUS_TYPE_INT32, &result,
489 static gboolean __bt_le_discovery_finished_cb(gpointer user_data)
491 int result = BLUETOOTH_ERROR_NONE;
494 if (_bt_get_discovering_property(DISCOVERY_ROLE_LE) == FALSE) {
495 if (_bt_get_cancel_by_user() == TRUE) {
496 result = BLUETOOTH_ERROR_CANCEL_BY_USER;
499 _bt_set_cancel_by_user(FALSE);
500 _bt_set_le_discovery_status(FALSE);
501 _bt_send_event(BT_LE_ADAPTER_EVENT,
502 BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED,
503 DBUS_TYPE_INT32, &result,
510 void __bt_update_remote_cache_devinfo(const char *address, gboolean paired_status)
514 ret_if(address == NULL);
517 bt_cache_info_t *cache_info;
518 bt_remote_dev_info_t *dev_info;
520 node = g_list_first(p_cache_list);
522 while (node != NULL){
523 cache_info = (bt_cache_info_t *)node->data;
525 if (cache_info == NULL) {
526 node = g_list_next(node);
530 dev_info = cache_info->dev_info;
531 if (strcasecmp(dev_info->address,
533 BT_DBG("Device Found");
534 if (paired_status == TRUE)
535 cache_info->dev_info->paired = TRUE;
537 cache_info->dev_info->paired = FALSE;
540 node = g_list_next(node);
545 static void __bt_device_remote_connected_properties(
546 bt_remote_dev_info_t *remote_dev_info,
547 char *address, gboolean connected)
549 int result = BLUETOOTH_ERROR_NONE;
554 if (remote_dev_info->uuid_count > 0 ) {
555 for (i = 0; i<remote_dev_info->uuid_count; i++) {
556 char *uuid = remote_dev_info->uuids[i];
557 if (strcasecmp(uuid, HID_UUID) == 0){
558 int event = BLUETOOTH_EVENT_NONE;
560 event = (connected == TRUE) ?
561 BLUETOOTH_HID_CONNECTED :
562 BLUETOOTH_HID_DISCONNECTED;
564 _bt_send_event(BT_HID_EVENT, event,
565 DBUS_TYPE_INT32, &result,
566 DBUS_TYPE_STRING, &address,
576 void _bt_handle_adapter_event(DBusMessage *msg)
580 int result = BLUETOOTH_ERROR_NONE;
581 DBusMessageIter item_iter;
582 const char *member = dbus_message_get_member(msg);
584 ret_if(member == NULL);
586 if (strcasecmp(member, "DeviceCreated") == 0) {
587 const char *object_path = NULL;
589 bt_remote_dev_info_t *remote_dev_info;
591 ret_if(_bt_is_device_creating() == FALSE);
593 /* Bonding from remote device */
594 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
596 dbus_message_iter_init(msg, &item_iter);
597 dbus_message_iter_get_basic(&item_iter, &object_path);
598 dbus_message_iter_next(&item_iter);
600 _bt_convert_device_path_to_address(object_path, address);
602 remote_dev_info = _bt_get_remote_device_info(address);
603 if (remote_dev_info == NULL) {
608 _bt_free_device_info(remote_dev_info);
610 } else if (strcasecmp(member, "InterfacesRemoved") == 0) {
611 const char *object_path = NULL;
613 bt_cache_info_t *cache_info;
614 bt_remote_dev_info_t *dev_info;
617 /* Bonding from remote device */
618 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
620 dbus_message_iter_init(msg, &item_iter);
621 dbus_message_iter_get_basic(&item_iter, &object_path);
622 dbus_message_iter_next(&item_iter);
624 _bt_convert_device_path_to_address(object_path, address);
626 node = g_list_first(p_cache_list);
628 while (node != NULL){
629 cache_info = (bt_cache_info_t *)node->data;
631 if (cache_info == NULL) {
632 node = g_list_next(node);
636 dev_info = cache_info->dev_info;
637 if (strcasecmp(dev_info->address,
639 p_cache_list = g_list_remove(p_cache_list,
641 __bt_free_cache_info(cache_info);
644 node = g_list_next(node);
648 } else if (strcasecmp(member, "AdvertisingEnabled") == 0) {
649 BT_DBG("Advertising Enabled");
652 gboolean status = FALSE;
654 dbus_message_iter_init(msg, &item_iter);
656 dbus_message_iter_get_basic(&item_iter, &slot_id);
657 dbus_message_iter_next(&item_iter);
658 dbus_message_iter_get_basic(&item_iter, &status);
660 BT_DBG("Advertising Enabled : slot_id [%d] status [%d]", slot_id, status);
662 /* Send event to application */
663 _bt_set_advertising_status(slot_id, status);
665 sender = _bt_get_adv_slot_owner(slot_id);
667 bluetooth_advertising_params_t adv_params = {0, };
669 _bt_get_advertising_params(&adv_params);
670 _bt_send_event_to_dest(sender, BT_ADAPTER_EVENT,
671 BLUETOOTH_EVENT_ADVERTISING_STARTED,
672 DBUS_TYPE_INT32, &result,
673 DBUS_TYPE_DOUBLE, &adv_params.interval_min,
674 DBUS_TYPE_DOUBLE, &adv_params.interval_max,
677 _bt_send_event_to_dest(sender, BT_ADAPTER_EVENT,
678 BLUETOOTH_EVENT_ADVERTISING_STOPPED,
679 DBUS_TYPE_INT32, &result,
682 } else if (strcasecmp(member, "RssiEnabled") == 0) {
683 BT_DBG("RSSI Enabled");
684 gboolean status = FALSE;
685 char *address = NULL;
688 dbus_message_iter_init(msg, &item_iter);
689 dbus_message_iter_get_basic(&item_iter, &address);
690 dbus_message_iter_next(&item_iter);
691 dbus_message_iter_get_basic(&item_iter, &link_type);
692 dbus_message_iter_next(&item_iter);
693 dbus_message_iter_get_basic(&item_iter, &status);
695 BT_DBG("RSSI Enabled [%s %d]", address, status);
696 _bt_send_event(BT_DEVICE_EVENT,
697 BLUETOOTH_EVENT_RSSI_ENABLED,
698 DBUS_TYPE_INT32, &result,
699 DBUS_TYPE_STRING, &address,
700 DBUS_TYPE_INT32, &link_type,
701 DBUS_TYPE_BOOLEAN, &status,
703 } else if (strcasecmp(member, "RssiAlert") == 0) {
704 BT_DBG("RSSI Alert");
708 char *address = NULL;
710 dbus_message_iter_init(msg, &item_iter);
711 dbus_message_iter_get_basic(&item_iter, &address);
712 dbus_message_iter_next(&item_iter);
713 dbus_message_iter_get_basic(&item_iter, &link_type);
714 dbus_message_iter_next(&item_iter);
715 dbus_message_iter_get_basic(&item_iter, &alert_type);
716 dbus_message_iter_next(&item_iter);
717 dbus_message_iter_get_basic(&item_iter, &rssi_dbm);
719 BT_DBG("RSSI Alert: [Address %s LinkType %d] [Type %d DBM %d]",
720 address, alert_type, rssi_dbm);
722 _bt_send_event(BT_DEVICE_EVENT,
723 BLUETOOTH_EVENT_RSSI_ALERT,
724 DBUS_TYPE_INT32, &result,
725 DBUS_TYPE_STRING, &address,
726 DBUS_TYPE_INT32, &link_type,
727 DBUS_TYPE_INT32, &alert_type,
728 DBUS_TYPE_INT32, &rssi_dbm,
730 } else if (strcasecmp(member, "RawRssi") == 0) {
734 char *address = NULL;
736 dbus_message_iter_init(msg, &item_iter);
737 dbus_message_iter_get_basic(&item_iter, &address);
738 dbus_message_iter_next(&item_iter);
739 dbus_message_iter_get_basic(&item_iter, &link_type);
740 dbus_message_iter_next(&item_iter);
741 dbus_message_iter_get_basic(&item_iter, &rssi_dbm);
743 BT_DBG("Raw RSSI: [Address %s] [Link Type %d][RSSI DBM %d]",
744 address, link_type, rssi_dbm);
746 _bt_send_event(BT_DEVICE_EVENT,
747 BLUETOOTH_EVENT_RAW_RSSI,
748 DBUS_TYPE_INT32, &result,
749 DBUS_TYPE_STRING, &address,
750 DBUS_TYPE_INT32, &link_type,
751 DBUS_TYPE_INT32, &rssi_dbm,
753 } else if (strcasecmp(member, BT_HARDWARE_ERROR) == 0) {
754 BT_ERR_C("Hardware error received from BLUEZ");
755 _bt_recover_adapter();
756 } else if (strcasecmp(member, BT_TX_TIMEOUT_ERROR) == 0) {
757 BT_ERR_C("Tx timeout error received from BLUEZ");
758 _bt_recover_adapter();
763 static void __bt_adapter_property_changed_event(DBusMessageIter *msg_iter, const char *path)
765 DBusGProxy *adapter_proxy;
767 int result = BLUETOOTH_ERROR_NONE;
768 DBusMessageIter value_iter;
769 DBusMessageIter dict_iter;
770 DBusMessageIter item_iter;
771 GValue timeout = { 0 };
772 const char *property = NULL;
774 dbus_message_iter_recurse(msg_iter, &item_iter);
776 if (dbus_message_iter_get_arg_type(&item_iter)
777 != DBUS_TYPE_DICT_ENTRY) {
778 BT_ERR("This is bad format dbus");
783 dbus_message_iter_recurse(&item_iter, &dict_iter);
785 dbus_message_iter_get_basic(&dict_iter, &property);
786 ret_if(property == NULL);
788 ret_if(!dbus_message_iter_next(&dict_iter));
790 if (strcasecmp(property, "Discovering") == 0) {
791 gboolean discovering = FALSE;
793 dbus_message_iter_recurse(&dict_iter, &value_iter);
794 dbus_message_iter_get_basic(&value_iter, &discovering);
796 /* Send event to application */
797 if (discovering == TRUE) {
798 _bt_set_discovery_status(TRUE);
799 _bt_send_event(BT_ADAPTER_EVENT,
800 BLUETOOTH_EVENT_DISCOVERY_STARTED,
801 DBUS_TYPE_INT32, &result,
804 ret_if(event_id > 0);
806 adapter_proxy = _bt_get_adapter_proxy();
807 ret_if(adapter_proxy == NULL);
809 /* Need to stop searching */
810 dbus_g_proxy_call(adapter_proxy,
816 event_id = g_timeout_add(BT_DISCOVERY_FINISHED_DELAY,
817 (GSourceFunc)_bt_discovery_finished_cb, NULL);
819 } else if (strcasecmp(property, "LEDiscovering") == 0) {
820 gboolean le_discovering = FALSE;
822 dbus_message_iter_recurse(&dict_iter, &value_iter);
823 dbus_message_iter_get_basic(&value_iter, &le_discovering);
825 /* Send event to application */
826 if (le_discovering == TRUE) {
827 _bt_set_le_discovery_status(TRUE);
828 _bt_send_event(BT_LE_ADAPTER_EVENT,
829 BLUETOOTH_EVENT_LE_DISCOVERY_STARTED,
830 DBUS_TYPE_INT32, &result,
833 ret_if(event_id > 0);
835 adapter_proxy = _bt_get_adapter_proxy();
836 ret_if(adapter_proxy == NULL);
838 /* Need to stop searching */
839 dbus_g_proxy_call(adapter_proxy,
845 event_id = g_timeout_add(BT_DISCOVERY_FINISHED_DELAY,
846 (GSourceFunc)__bt_le_discovery_finished_cb, NULL);
848 } else if (strcasecmp(property, "Name") == 0) {
851 dbus_message_iter_recurse(&dict_iter, &value_iter);
852 dbus_message_iter_get_basic(&value_iter, &name);
854 /* Send event to application */
855 _bt_send_event(BT_ADAPTER_EVENT,
856 BLUETOOTH_EVENT_LOCAL_NAME_CHANGED,
857 DBUS_TYPE_INT32, &result,
858 DBUS_TYPE_STRING, &name,
860 } else if (strcasecmp(property, "Alias") == 0) {
863 dbus_message_iter_recurse(&dict_iter, &value_iter);
864 dbus_message_iter_get_basic(&value_iter, &alias);
866 /* Send event to application */
867 _bt_send_event(BT_ADAPTER_EVENT,
868 BLUETOOTH_EVENT_LOCAL_NAME_CHANGED,
869 DBUS_TYPE_INT32, &result,
870 DBUS_TYPE_STRING, &alias,
872 } else if (strcasecmp(property, "Discoverable") == 0) {
873 gboolean discoverable = FALSE;
875 dbus_message_iter_recurse(&dict_iter, &value_iter);
876 dbus_message_iter_get_basic(&value_iter, &discoverable);
878 if (discoverable == FALSE) {
879 if (_bt_get_discoverable_timeout_property() > 0) {
880 g_value_init(&timeout, G_TYPE_UINT);
881 g_value_set_uint(&timeout, 0);
883 adapter_proxy = _bt_get_adapter_properties_proxy();
884 ret_if(adapter_proxy == NULL);
886 dbus_g_proxy_call_no_reply(adapter_proxy, "Set",
887 G_TYPE_STRING, BT_ADAPTER_INTERFACE,
888 G_TYPE_STRING, "DiscoverableTimeout",
889 G_TYPE_VALUE, &timeout,
892 g_value_unset(&timeout);
895 mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
897 /* Send event to application */
898 BT_INFO("[Connectable]");
899 _bt_send_event(BT_ADAPTER_EVENT,
900 BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
901 DBUS_TYPE_INT32, &result,
902 DBUS_TYPE_INT16, &mode,
905 _bt_get_discoverable_mode(&mode);
907 /* Event will be sent by "DiscoverableTimeout" signal */
908 if (mode != BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE)
911 /* Send event to application */
912 BT_INFO("[General Discoverable]");
913 _bt_send_event(BT_ADAPTER_EVENT,
914 BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
915 DBUS_TYPE_INT32, &result,
916 DBUS_TYPE_INT16, &mode,
919 } else if (strcasecmp(property, "DiscoverableTimeout") == 0) {
920 _bt_get_discoverable_mode(&mode);
922 /* Event was already sent by "Discoverable" signal */
923 if (mode == BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE ||
924 mode == BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE)
927 /* Send event to application */
928 BT_INFO("[Limited Discoverable (Timeout %u secs)]",
929 _bt_get_discoverable_timeout_property());
931 _bt_send_event(BT_ADAPTER_EVENT,
932 BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
933 DBUS_TYPE_INT32, &result,
934 DBUS_TYPE_INT16, &mode,
936 } else if (strcasecmp(property, "Powered") == 0) {
937 /* TODO: Need to check this operation!! */
938 gboolean powered = FALSE;
941 dbus_message_iter_recurse(&dict_iter, &value_iter);
942 dbus_message_iter_get_basic(&value_iter, &powered);
943 BT_DBG("Powered = %d", powered);
944 if (powered == FALSE) {
945 if (vconf_get_int(VCONFKEY_BT_STATUS, &bt_state) == 0 &&
946 bt_state != VCONFKEY_BT_STATUS_OFF) {
947 _bt_disable_adapter();
949 #ifdef ENABLE_TIZEN_2_4
950 if (vconf_get_int(VCONFKEY_BT_LE_STATUS, &bt_state) == 0 &&
951 bt_state != VCONFKEY_BT_LE_STATUS_OFF) {
952 _bt_set_le_disabled(BLUETOOTH_ERROR_NONE);
956 } else if (strcasecmp(property, "Connectable") == 0) {
957 gboolean connectable = FALSE;
959 dbus_message_iter_recurse(&dict_iter, &value_iter);
960 dbus_message_iter_get_basic(&value_iter, &connectable);
962 BT_DBG("Connectable property is changed : %d", connectable);
964 _bt_send_event(BT_ADAPTER_EVENT,
965 BLUETOOTH_EVENT_CONNECTABLE_CHANGED,
966 DBUS_TYPE_BOOLEAN, &connectable,
969 if (_bt_adapter_get_status() == BT_DEACTIVATING &&
970 _bt_adapter_get_le_status() == BT_LE_ACTIVATED &&
972 _bt_set_disabled(BLUETOOTH_ERROR_NONE);
973 } else if (strcasecmp(property, "SupportedLEFeatures") == 0) {
976 DBusMessageIter array_iter;
978 dbus_message_iter_recurse(&dict_iter, &value_iter);
980 if(dbus_message_iter_get_arg_type(&value_iter) == DBUS_TYPE_ARRAY) {
981 dbus_message_iter_recurse(&value_iter, &array_iter);
983 while (dbus_message_iter_get_arg_type(&array_iter) !=
985 dbus_message_iter_get_basic(&array_iter, &name);
986 if (!dbus_message_iter_next(&array_iter))
989 dbus_message_iter_get_basic(&array_iter, &val);
991 BT_DBG("name[%s] value[%s]", name, val);
993 if (FALSE == _bt_update_le_feature_support(name, val))
994 BT_INFO("Fail to update LE feature info");
996 if (!dbus_message_iter_next(&array_iter))
1001 BT_DBG("property : [%s]", property);
1003 } while(dbus_message_iter_next(&item_iter));
1006 static void __bt_obex_property_changed_event(DBusMessageIter *msg_iter, const char *path)
1010 DBusMessageIter value_iter;
1011 DBusMessageIter dict_iter;
1012 DBusMessageIter item_iter;
1013 const char *property = NULL;
1015 dbus_message_iter_recurse(msg_iter, &item_iter);
1017 if (dbus_message_iter_get_arg_type(&item_iter)
1018 != DBUS_TYPE_DICT_ENTRY) {
1019 BT_ERR("This is bad format dbus");
1024 dbus_message_iter_recurse(&item_iter, &dict_iter);
1026 dbus_message_iter_get_basic(&dict_iter, &property);
1027 ret_if(property == NULL);
1029 ret_if(!dbus_message_iter_next(&dict_iter));
1031 BT_DBG("property :%s", property);
1033 if (strcasecmp(property, "Status") == 0) {
1035 dbus_message_iter_recurse(&dict_iter, &value_iter);
1036 dbus_message_iter_get_basic(&value_iter, &status);
1038 if (strcasecmp(status, "active") == 0){
1039 _bt_obex_transfer_started(path);
1040 } else if (strcasecmp(status, "complete") == 0) {
1041 _bt_obex_transfer_completed(path, TRUE);
1042 _bt_pbap_obex_transfer_completed(path, TRUE);
1043 } else if (strcasecmp(status, "error") == 0){
1044 _bt_obex_transfer_completed(path, FALSE);
1045 _bt_pbap_obex_transfer_completed(path, FALSE);
1047 } else if (strcasecmp(property, "Transferred") == 0) {
1048 static int transferred = 0;
1049 dbus_message_iter_recurse(&dict_iter, &value_iter);
1050 dbus_message_iter_get_basic(&value_iter, &transferred);
1052 _bt_obex_transfer_progress(path,transferred);
1055 dbus_message_iter_next(&item_iter);
1056 } while (dbus_message_iter_get_arg_type(&item_iter) ==
1057 DBUS_TYPE_DICT_ENTRY);
1062 static void __bt_device_property_changed_event(DBusMessageIter *msg_iter, const char *path)
1067 int result = BLUETOOTH_ERROR_NONE;
1068 DBusMessageIter value_iter;
1069 DBusMessageIter dict_iter;
1070 DBusMessageIter item_iter;
1071 const char *property = NULL;
1073 bt_remote_dev_info_t *remote_dev_info;
1075 dbus_message_iter_recurse(msg_iter, &item_iter);
1077 if (dbus_message_iter_get_arg_type(&item_iter)
1078 != DBUS_TYPE_DICT_ENTRY) {
1079 BT_ERR("This is bad format dbus");
1084 dbus_message_iter_recurse(&item_iter, &dict_iter);
1086 dbus_message_iter_get_basic(&dict_iter, &property);
1087 ret_if(property == NULL);
1089 ret_if(!dbus_message_iter_next(&dict_iter));
1091 if (strcasecmp(property, "Connected") == 0) {
1092 gboolean connected = FALSE;
1094 dbus_message_iter_recurse(&dict_iter, &value_iter);
1095 dbus_message_iter_get_basic(&value_iter, &connected);
1097 event = connected ? BLUETOOTH_EVENT_DEVICE_CONNECTED :
1098 BLUETOOTH_EVENT_DEVICE_DISCONNECTED;
1100 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1102 _bt_convert_device_path_to_address(path, address);
1104 BT_DBG("connected: %d", connected);
1105 BT_DBG("address: %s", address);
1107 remote_dev_info = _bt_get_remote_device_info(address);
1109 if (remote_dev_info != NULL) {
1110 __bt_device_remote_connected_properties(
1111 remote_dev_info, address, connected);
1112 _bt_free_device_info(remote_dev_info);
1115 /* Send event to application */
1116 _bt_send_event(BT_DEVICE_EVENT,
1118 DBUS_TYPE_INT32, &result,
1119 DBUS_TYPE_STRING, &address,
1123 } else if (strcasecmp(property, "RSSI") == 0) {
1124 bt_remote_dev_info_t *remote_dev_info;
1126 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1128 _bt_convert_device_path_to_address(path, address);
1129 BT_DBG("address: %s", address);
1131 remote_dev_info = _bt_get_remote_device_info(address);
1132 if (remote_dev_info == NULL) {
1136 BT_DBG("Address type %d", remote_dev_info->addr_type);
1138 if (remote_dev_info && remote_dev_info->addr_type == 0) {
1139 BT_DBG("Name %s", remote_dev_info->name);
1141 _bt_send_event(BT_ADAPTER_EVENT,
1142 BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND,
1143 DBUS_TYPE_INT32, &result,
1144 DBUS_TYPE_STRING, &remote_dev_info->address,
1145 DBUS_TYPE_UINT32, &remote_dev_info->class,
1146 DBUS_TYPE_INT16, &remote_dev_info->rssi,
1147 DBUS_TYPE_STRING, &remote_dev_info->name,
1148 DBUS_TYPE_BOOLEAN, &remote_dev_info->paired,
1149 DBUS_TYPE_BOOLEAN, &remote_dev_info->connected,
1150 DBUS_TYPE_BOOLEAN, &remote_dev_info->trust,
1151 DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
1152 &remote_dev_info->uuids, remote_dev_info->uuid_count,
1153 DBUS_TYPE_INT16, &remote_dev_info->manufacturer_data_len,
1154 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
1155 &remote_dev_info->manufacturer_data, remote_dev_info->manufacturer_data_len,
1158 _bt_free_device_info(remote_dev_info);
1160 } else if (strcasecmp(property, "GattConnected") == 0) {
1161 gboolean gatt_connected = FALSE;
1163 dbus_message_iter_recurse(&dict_iter, &value_iter);
1164 dbus_message_iter_get_basic(&value_iter, &gatt_connected);
1166 event = gatt_connected ? BLUETOOTH_EVENT_GATT_CONNECTED :
1167 BLUETOOTH_EVENT_GATT_DISCONNECTED;
1169 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1171 _bt_convert_device_path_to_address(path, address);
1173 BT_DBG("gatt_connected: %d", gatt_connected);
1174 BT_DBG("address: %s", address);
1176 /* Send event to application */
1177 _bt_send_event(BT_DEVICE_EVENT,
1179 DBUS_TYPE_INT32, &result,
1180 DBUS_TYPE_STRING, &address,
1184 } else if (strcasecmp(property, "Paired") == 0) {
1185 gboolean paired = FALSE;
1186 bt_remote_dev_info_t *remote_dev_info;
1188 dbus_message_iter_recurse(&dict_iter, &value_iter);
1189 dbus_message_iter_get_basic(&value_iter, &paired);
1191 _bt_agent_set_canceled(FALSE);
1192 /* BlueZ sends paired signal for each paired device */
1193 /* during activation, We should ignore this, otherwise*/
1194 /* application thinks that a new device got paired */
1195 if (_bt_adapter_get_status() != BT_ACTIVATED) {
1196 BT_DBG("BT is not activated, so ignore this");
1200 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1202 _bt_convert_device_path_to_address(path, address);
1204 remote_dev_info = _bt_get_remote_device_info(address);
1205 if (remote_dev_info == NULL) {
1210 if(paired == FALSE) {
1211 BT_INFO("Unpaired: %s", address);
1212 __bt_update_remote_cache_devinfo(address, FALSE);
1213 _bt_send_event(BT_ADAPTER_EVENT,
1214 BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED,
1215 DBUS_TYPE_INT32, &result,
1216 DBUS_TYPE_STRING, &address,
1219 BT_INFO("Paired: %s", address);
1220 __bt_update_remote_cache_devinfo(address, TRUE);
1222 if (_bt_is_device_creating() == TRUE) {
1223 BT_DBG("Try to Pair by me");
1224 _bt_free_device_info(remote_dev_info);
1229 _bt_send_event(BT_ADAPTER_EVENT,
1230 BLUETOOTH_EVENT_BONDING_FINISHED,
1231 DBUS_TYPE_INT32, &result,
1232 DBUS_TYPE_STRING, &address,
1233 DBUS_TYPE_UINT32, &remote_dev_info->class,
1234 DBUS_TYPE_INT16, &remote_dev_info->rssi,
1235 DBUS_TYPE_STRING, &remote_dev_info->name,
1236 DBUS_TYPE_BOOLEAN, &remote_dev_info->paired,
1237 DBUS_TYPE_BOOLEAN, &remote_dev_info->connected,
1238 DBUS_TYPE_BOOLEAN, &remote_dev_info->trust,
1239 DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
1240 &remote_dev_info->uuids, remote_dev_info->uuid_count,
1241 DBUS_TYPE_INT16, &remote_dev_info->manufacturer_data_len,
1242 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
1243 &remote_dev_info->manufacturer_data, remote_dev_info->manufacturer_data_len,
1246 _bt_free_device_info(remote_dev_info);
1248 } else if (strcasecmp(property, "LegacyPaired") == 0) {
1249 gboolean paired = FALSE;
1250 bt_remote_dev_info_t *remote_dev_info;
1252 if (_bt_adapter_get_status() != BT_ACTIVATED) {
1253 BT_DBG("BT is not activated, so ignore this");
1257 dbus_message_iter_recurse(&dict_iter, &value_iter);
1258 dbus_message_iter_get_basic(&value_iter, &paired);
1259 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1260 BT_DBG("LegacyPaired: %d", paired);
1261 _bt_convert_device_path_to_address(path, address);
1263 remote_dev_info = _bt_get_remote_device_info(address);
1264 if (remote_dev_info == NULL) {
1269 BT_DBG("LegacyPairing Failed with %s. Show Error Popup",
1270 remote_dev_info->name);
1271 _bt_launch_system_popup(BT_AGENT_EVENT_LEGACY_PAIR_FAILED_FROM_REMOTE,
1272 remote_dev_info->name, NULL, NULL, NULL);
1274 _bt_free_device_info(remote_dev_info);
1276 } else if (strcasecmp(property, "Trusted") == 0) {
1277 gboolean trusted = FALSE;
1279 dbus_message_iter_recurse(&dict_iter, &value_iter);
1280 dbus_message_iter_get_basic(&value_iter, &trusted);
1282 event = trusted ? BLUETOOTH_EVENT_DEVICE_AUTHORIZED :
1283 BLUETOOTH_EVENT_DEVICE_UNAUTHORIZED;
1285 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1287 _bt_convert_device_path_to_address(path, address);
1289 BT_DBG("trusted: %d", trusted);
1290 BT_DBG("address: %s", address);
1292 /* Send event to application */
1293 _bt_send_event(BT_DEVICE_EVENT,
1295 DBUS_TYPE_INT32, &result,
1296 DBUS_TYPE_STRING, &address,
1301 dbus_message_iter_next(&item_iter);
1302 } while (dbus_message_iter_get_arg_type(&item_iter) ==
1303 DBUS_TYPE_DICT_ENTRY);
1307 static void __bt_media_control_changed_event(DBusMessageIter *msg_iter, const char *path)
1310 int result = BLUETOOTH_ERROR_NONE;
1311 DBusMessageIter value_iter;
1312 DBusMessageIter dict_iter;
1313 DBusMessageIter item_iter;
1314 const char *property = NULL;
1316 bt_remote_dev_info_t *remote_dev_info;
1318 dbus_message_iter_recurse(msg_iter, &item_iter);
1320 if (dbus_message_iter_get_arg_type(&item_iter)
1321 != DBUS_TYPE_DICT_ENTRY) {
1322 BT_ERR("This is bad format dbus");
1326 dbus_message_iter_recurse(&item_iter, &dict_iter);
1328 dbus_message_iter_get_basic(&dict_iter, &property);
1329 ret_if(property == NULL);
1331 ret_if(!dbus_message_iter_next(&dict_iter));
1333 if (strcasecmp(property, "Connected") == 0) {
1334 gboolean connected = FALSE;
1336 dbus_message_iter_recurse(&dict_iter, &value_iter);
1337 dbus_message_iter_get_basic(&value_iter, &connected);
1339 event = connected ? BLUETOOTH_EVENT_AVRCP_CONNECTED :
1340 BLUETOOTH_EVENT_AVRCP_DISCONNECTED;
1342 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1344 _bt_convert_device_path_to_address(path, address);
1346 BT_DBG("connected: %d", connected);
1347 BT_DBG("address: %s", address);
1349 remote_dev_info = _bt_get_remote_device_info(address);
1351 if (remote_dev_info != NULL) {
1352 __bt_device_remote_connected_properties(
1353 remote_dev_info, address, connected);
1354 _bt_free_device_info(remote_dev_info);
1357 /* Send event to application */
1358 _bt_send_event(BT_AVRCP_EVENT,
1360 DBUS_TYPE_INT32, &result,
1361 DBUS_TYPE_STRING, &address,
1369 void _bt_handle_property_changed_event(DBusMessage *msg)
1371 DBusMessageIter item_iter;
1372 const char *member = dbus_message_get_member(msg);
1373 const char *interface_name = NULL;
1375 ret_if(member == NULL);
1377 dbus_message_iter_init(msg, &item_iter);
1379 if (dbus_message_iter_get_arg_type(&item_iter)
1380 != DBUS_TYPE_STRING) {
1381 BT_ERR("This is bad format dbus");
1385 dbus_message_iter_get_basic(&item_iter, &interface_name);
1387 ret_if(interface_name == NULL);
1389 ret_if(dbus_message_iter_next(&item_iter) == FALSE);
1391 ret_if(dbus_message_iter_get_arg_type(&item_iter) != DBUS_TYPE_ARRAY);
1393 if (strcasecmp(interface_name, BT_ADAPTER_INTERFACE) == 0) {
1394 __bt_adapter_property_changed_event(&item_iter,
1395 dbus_message_get_path(msg));
1396 } else if (strcasecmp(interface_name, BT_DEVICE_INTERFACE) == 0) {
1397 __bt_device_property_changed_event(&item_iter,
1398 dbus_message_get_path(msg));
1399 } else if (strcasecmp(interface_name, BT_OBEX_TRANSFER_INTERFACE) == 0) {
1400 BT_DBG("BT_OBEX_TRANSFER_INTERFACE");
1401 __bt_obex_property_changed_event(&item_iter,
1402 dbus_message_get_path(msg));
1403 } else if (strcasecmp(interface_name, BT_MEDIA_CONTROL_INTERFACE) == 0) {
1404 __bt_media_control_changed_event(&item_iter,
1405 dbus_message_get_path(msg));
1406 } else if (strcasecmp(interface_name, BT_PLAYER_CONTROL_INTERFACE) == 0) {
1407 _bt_handle_avrcp_control_event(&item_iter,
1408 dbus_message_get_path(msg));
1409 } else if (strcasecmp(interface_name, BT_NETWORK_CLIENT_INTERFACE) == 0) {
1410 BT_DBG("BT_NETWORK_CLIENT_INTERFACE");
1411 _bt_handle_network_client_event(&item_iter,
1412 dbus_message_get_path(msg));
1416 void __bt_opc_property_changed_event(DBusMessageIter *msg_iter,
1419 DBusMessageIter value_iter;
1420 DBusMessageIter dict_iter;
1421 DBusMessageIter item_iter;
1422 const char *property = NULL;
1424 dbus_message_iter_recurse(msg_iter, &item_iter);
1426 if (dbus_message_iter_get_arg_type(&item_iter)
1427 != DBUS_TYPE_DICT_ENTRY) {
1428 BT_ERR("This is bad format dbus");
1432 dbus_message_iter_recurse(&item_iter, &dict_iter);
1434 dbus_message_iter_get_basic(&dict_iter, &property);
1435 ret_if(property == NULL);
1437 ret_if(!dbus_message_iter_next(&dict_iter));
1439 if (strcasecmp(property, "Status") == 0) {
1440 const char *status = NULL;
1441 dbus_message_iter_recurse(&dict_iter, &value_iter);
1442 dbus_message_iter_get_basic(&value_iter, &status);
1444 BT_INFO("Status is %s", status);
1446 if(strcasecmp(status, "active") == 0){
1447 _bt_obex_client_started(path);
1448 }else if (strcasecmp(status, "complete") == 0) {
1449 _bt_obex_client_completed(path, TRUE);
1450 }else if (strcasecmp(status, "error") == 0){
1451 _bt_obex_client_completed(path, FALSE);
1453 } else if (strcasecmp(property, "Transferred") == 0) {
1454 static int transferred = 0;
1455 dbus_message_iter_recurse(&dict_iter, &value_iter);
1456 dbus_message_iter_get_basic(&value_iter, &transferred);
1458 _bt_obex_client_progress(path, transferred);
1460 BT_DBG("property : [%s]", property);
1464 void _bt_opc_property_changed_event(DBusMessage *msg)
1466 DBusMessageIter item_iter;
1467 const char *member = dbus_message_get_member(msg);
1468 const char *interface_name = NULL;
1470 ret_if(member == NULL);
1472 dbus_message_iter_init(msg, &item_iter);
1474 if (dbus_message_iter_get_arg_type(&item_iter)
1475 != DBUS_TYPE_STRING) {
1476 BT_ERR("This is bad format dbus");
1480 dbus_message_iter_get_basic(&item_iter, &interface_name);
1482 ret_if(interface_name == NULL);
1484 BT_DBG("interface: %s", interface_name);
1486 ret_if(dbus_message_iter_next(&item_iter) == FALSE);
1488 ret_if(dbus_message_iter_get_arg_type(&item_iter) != DBUS_TYPE_ARRAY);
1490 if (strcasecmp(interface_name, BT_OBEX_TRANSFER_INTERFACE) == 0) {
1491 __bt_opc_property_changed_event(&item_iter,
1492 dbus_message_get_path(msg));
1494 BT_DBG("interface_name : [%s]", interface_name);
1499 void _bt_handle_input_event(DBusMessage *msg)
1501 int result = BLUETOOTH_ERROR_NONE;
1502 DBusMessageIter item_iter;
1503 DBusMessageIter value_iter;
1504 gboolean property_flag = FALSE;
1505 const char *member = dbus_message_get_member(msg);
1506 const char *path = dbus_message_get_path(msg);
1507 const char *property = NULL;
1508 bt_remote_dev_info_t *remote_dev_info;
1510 ret_if(member == NULL);
1512 dbus_message_iter_init(msg, &item_iter);
1514 if (dbus_message_iter_get_arg_type(&item_iter)
1515 != DBUS_TYPE_STRING) {
1516 BT_ERR("This is bad format dbus");
1520 dbus_message_iter_get_basic(&item_iter, &property);
1522 ret_if(property == NULL);
1524 if (strcasecmp(property, "Connected") == 0) {
1525 int event = BLUETOOTH_EVENT_NONE;
1528 dbus_message_iter_next(&item_iter);
1529 dbus_message_iter_recurse(&item_iter, &value_iter);
1530 dbus_message_iter_get_basic(&value_iter, &property_flag);
1532 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1534 _bt_convert_device_path_to_address(path, address);
1536 event = (property_flag == TRUE) ?
1537 BLUETOOTH_HID_CONNECTED :
1538 BLUETOOTH_HID_DISCONNECTED;
1540 _bt_send_event(BT_HID_EVENT, event,
1541 DBUS_TYPE_INT32, &result,
1542 DBUS_TYPE_STRING, &address,
1545 /* Check HID connection type (Keyboard or Mouse) and update the status */
1546 remote_dev_info = _bt_get_remote_device_info(address);
1548 if (property_flag == TRUE) {
1549 hid_connected_device_count++;
1550 __bt_set_device_values(TRUE,
1551 VCONFKEY_BT_DEVICE_HID_CONNECTED);
1553 hid_connected_device_count--;
1554 if (hid_connected_device_count == 0)
1555 __bt_set_device_values(FALSE,
1556 VCONFKEY_BT_DEVICE_HID_CONNECTED);
1559 if (remote_dev_info != NULL) {
1560 BT_DBG("HID device class [%x]", remote_dev_info->class);
1561 if (remote_dev_info->class &
1562 BLUETOOTH_DEVICE_MINOR_CLASS_KEY_BOARD) {
1563 #ifdef ENABLE_TIZEN_2_4
1564 __bt_set_device_values(property_flag,
1565 VCONFKEY_BT_DEVICE_HID_KEYBOARD_CONNECTED);
1570 if (remote_dev_info->class &
1571 BLUETOOTH_DEVICE_MINOR_CLASS_POINTING_DEVICE)
1573 #ifdef ENABLE_TIZEN_2_4
1574 __bt_set_device_values(property_flag,
1575 VCONFKEY_BT_DEVICE_HID_MOUSE_CONNECTED);
1578 _bt_free_device_info(remote_dev_info);
1585 void _bt_handle_network_server_event(DBusMessage *msg)
1587 int result = BLUETOOTH_ERROR_NONE;
1588 char *address = NULL;
1589 char *device = NULL;
1590 const char *member = dbus_message_get_member(msg);
1592 ret_if(member == NULL);
1594 if (strcasecmp(member, "PeerConnected") == 0) {
1595 if (!dbus_message_get_args(msg, NULL,
1596 DBUS_TYPE_STRING, &device,
1597 DBUS_TYPE_STRING, &address,
1598 DBUS_TYPE_INVALID)) {
1599 BT_ERR("Unexpected parameters in signal");
1603 __bt_set_device_values(TRUE,
1604 VCONFKEY_BT_DEVICE_PAN_CONNECTED);
1606 _bt_send_event(BT_NETWORK_EVENT, BLUETOOTH_EVENT_NETWORK_SERVER_CONNECTED,
1607 DBUS_TYPE_INT32, &result,
1608 DBUS_TYPE_STRING, &device,
1609 DBUS_TYPE_STRING, &address,
1611 nap_connected_device_count++;
1612 } else if (strcasecmp(member, "PeerDisconnected") == 0) {
1613 if (!dbus_message_get_args(msg, NULL,
1614 DBUS_TYPE_STRING, &device,
1615 DBUS_TYPE_STRING, &address,
1616 DBUS_TYPE_INVALID)) {
1617 BT_ERR("Unexpected parameters in signal");
1620 nap_connected_device_count--;
1621 if (nap_connected_device_count == 0)
1622 __bt_set_device_values(FALSE,
1623 VCONFKEY_BT_DEVICE_PAN_CONNECTED);
1625 _bt_send_event(BT_NETWORK_EVENT, BLUETOOTH_EVENT_NETWORK_SERVER_DISCONNECTED,
1626 DBUS_TYPE_INT32, &result,
1627 DBUS_TYPE_STRING, &device,
1628 DBUS_TYPE_STRING, &address,
1633 void _bt_handle_network_client_event(DBusMessageIter *msg_iter,
1638 int result = BLUETOOTH_ERROR_NONE;
1639 DBusMessageIter item_iter;
1640 DBusMessageIter dict_iter;
1641 DBusMessageIter value_iter;
1642 gboolean property_flag = FALSE;
1643 const char *property = NULL;
1645 dbus_message_iter_recurse(msg_iter, &item_iter);
1647 if (dbus_message_iter_get_arg_type(&item_iter)
1648 != DBUS_TYPE_DICT_ENTRY) {
1649 BT_ERR("This is bad format dbus");
1653 dbus_message_iter_recurse(&item_iter, &dict_iter);
1654 dbus_message_iter_get_basic(&dict_iter, &property);
1656 ret_if(property == NULL);
1657 ret_if(!dbus_message_iter_next(&dict_iter));
1659 if (strcasecmp(property, "Connected") == 0) {
1660 int event = BLUETOOTH_EVENT_NONE;
1663 dbus_message_iter_recurse(&dict_iter, &value_iter);
1664 dbus_message_iter_get_basic(&value_iter, &property_flag);
1666 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1668 _bt_convert_device_path_to_address(path, address);
1670 BT_DBG("property_flag %d", property_flag);
1671 if (property_flag == TRUE) {
1672 event = BLUETOOTH_EVENT_NETWORK_CONNECTED;
1673 nap_connected_device_count++;
1674 __bt_set_device_values(TRUE,
1675 VCONFKEY_BT_DEVICE_PAN_CONNECTED);
1677 event = BLUETOOTH_EVENT_NETWORK_DISCONNECTED;
1678 nap_connected_device_count--;
1679 if (nap_connected_device_count == 0)
1680 __bt_set_device_values(FALSE,
1681 VCONFKEY_BT_DEVICE_PAN_CONNECTED);
1684 _bt_send_event(BT_NETWORK_EVENT, event,
1685 DBUS_TYPE_INT32, &result,
1686 DBUS_TYPE_STRING, &address,
1694 void _bt_handle_device_event(DBusMessage *msg)
1697 int result = BLUETOOTH_ERROR_NONE;
1698 DBusMessageIter item_iter;
1699 DBusMessageIter value_iter;
1701 const char *member = dbus_message_get_member(msg);
1702 const char *path = dbus_message_get_path(msg);
1703 const char *property = NULL;
1705 ret_if(path == NULL);
1706 ret_if(member == NULL);
1708 if (strcasecmp(member, "PropertyChanged") == 0) {
1709 dbus_message_iter_init(msg, &item_iter);
1711 if (dbus_message_iter_get_arg_type(&item_iter)
1712 != DBUS_TYPE_STRING) {
1713 BT_ERR("This is bad format dbus");
1717 dbus_message_iter_get_basic(&item_iter, &property);
1719 ret_if(property == NULL);
1721 if (strcasecmp(property, "GattConnected") == 0) {
1722 gboolean connected = FALSE;
1725 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1726 _bt_convert_device_path_to_address(path, address);
1728 dbus_message_iter_next(&item_iter);
1729 dbus_message_iter_recurse(&item_iter, &value_iter);
1730 dbus_message_iter_get_basic(&value_iter, &connected);
1732 event = connected ? BLUETOOTH_EVENT_GATT_CONNECTED :
1733 BLUETOOTH_EVENT_GATT_DISCONNECTED;
1735 _bt_send_event(BT_DEVICE_EVENT,
1737 DBUS_TYPE_INT32, &result,
1738 DBUS_TYPE_STRING, &address,
1742 } else if (strcasecmp(property, "Paired") == 0) {
1743 gboolean paired = FALSE;
1744 bt_remote_dev_info_t *remote_dev_info;
1745 dbus_message_iter_next(&item_iter);
1746 dbus_message_iter_recurse(&item_iter, &value_iter);
1747 dbus_message_iter_get_basic(&value_iter, &paired);
1749 ret_if(paired == FALSE);
1751 /* BlueZ sends paired signal for each paired device */
1752 /* during activation, We should ignore this, otherwise*/
1753 /* application thinks that a new device got paired */
1754 if (_bt_adapter_get_status() != BT_ACTIVATED) {
1755 BT_DBG("BT is not activated, so ignore this");
1759 if (_bt_is_device_creating() == TRUE) {
1760 BT_DBG("Try to Pair by me");
1764 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1766 _bt_convert_device_path_to_address(path, address);
1768 remote_dev_info = _bt_get_remote_device_info(address);
1769 if (remote_dev_info == NULL) {
1774 _bt_send_event(BT_ADAPTER_EVENT,
1775 BLUETOOTH_EVENT_BONDING_FINISHED,
1776 DBUS_TYPE_INT32, &result,
1777 DBUS_TYPE_STRING, &address,
1778 DBUS_TYPE_UINT32, &remote_dev_info->class,
1779 DBUS_TYPE_INT16, &remote_dev_info->rssi,
1780 DBUS_TYPE_STRING, &remote_dev_info->name,
1781 DBUS_TYPE_BOOLEAN, &remote_dev_info->paired,
1782 DBUS_TYPE_BOOLEAN, &remote_dev_info->connected,
1783 DBUS_TYPE_BOOLEAN, &remote_dev_info->trust,
1784 DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
1785 &remote_dev_info->uuids, remote_dev_info->uuid_count,
1786 DBUS_TYPE_INT16, &remote_dev_info->manufacturer_data_len,
1787 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
1788 &remote_dev_info->manufacturer_data, remote_dev_info->manufacturer_data_len,
1791 _bt_free_device_info(remote_dev_info);
1794 } else if (strcasecmp(property, "UUIDs") == 0) {
1795 /* Once we get the updated uuid information after
1796 * reverse service search, update it to application */
1798 bt_remote_dev_info_t *remote_dev_info;
1800 ret_if(_bt_is_device_creating() == TRUE);
1802 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1804 _bt_convert_device_path_to_address(path, address);
1806 remote_dev_info = _bt_get_remote_device_info(address);
1807 if (remote_dev_info == NULL) {
1812 BT_DBG("UUID's count = %d", remote_dev_info->uuid_count);
1813 if (remote_dev_info->paired && remote_dev_info->uuid_count)
1814 _bt_send_event(BT_ADAPTER_EVENT,
1815 BLUETOOTH_EVENT_SERVICE_SEARCHED,
1816 DBUS_TYPE_INT32, &result,
1817 DBUS_TYPE_STRING, &address,
1818 DBUS_TYPE_UINT32, &remote_dev_info->class,
1819 DBUS_TYPE_INT16, &remote_dev_info->rssi,
1820 DBUS_TYPE_STRING, &remote_dev_info->name,
1821 DBUS_TYPE_BOOLEAN, &remote_dev_info->paired,
1822 DBUS_TYPE_BOOLEAN, &remote_dev_info->connected,
1823 DBUS_TYPE_BOOLEAN, &remote_dev_info->trust,
1824 DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
1825 &remote_dev_info->uuids, remote_dev_info->uuid_count,
1828 _bt_free_device_info(remote_dev_info);
1831 } else if (strcasecmp(member, "DeviceConnected") == 0) {
1832 unsigned char addr_type = 0;
1834 dbus_message_iter_init(msg, &item_iter);
1835 dbus_message_iter_get_basic(&item_iter, &addr_type);
1837 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1839 _bt_convert_device_path_to_address(path, address);
1841 BT_INFO("Address : %s Type : %d", address, addr_type);
1842 BT_ERR_C("Connected [%s]", !addr_type ? "BREDR" : "LE");
1844 _bt_logging_connection(TRUE, addr_type);
1845 // journal_bt_connected();
1847 /*Send event to application*/
1848 _bt_send_event(BT_DEVICE_EVENT,
1849 BLUETOOTH_EVENT_DEVICE_CONNECTED,
1850 DBUS_TYPE_INT32, &result,
1851 DBUS_TYPE_STRING, &address,
1852 DBUS_TYPE_BYTE, &addr_type,
1856 } else if (strcasecmp(member, "Disconnected") == 0) {
1857 unsigned char disc_reason = 0;
1858 unsigned char addr_type = 0;
1859 gboolean sending = FALSE;
1861 if (!dbus_message_get_args(msg, NULL,
1862 DBUS_TYPE_BYTE, &addr_type,
1863 DBUS_TYPE_BYTE, &disc_reason,
1867 result = disc_reason;
1869 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1871 _bt_convert_device_path_to_address(path, address);
1872 // journal_bt_disconnected();
1874 /* 0x00 BDADDR_BRDER
1875 0x01 BDADDR_LE_PUBLIC
1876 0x02 BDADDR_LE_RANDOM */
1877 BT_INFO("Address : %s Type : %d", address, addr_type);
1878 BT_ERR_C("Disconnected [%s] [%d : %s]", !addr_type ? "BREDR" : "LE",
1879 disc_reason, _bt_convert_disc_reason_to_string(disc_reason));
1881 _bt_headset_set_local_connection(FALSE);
1882 _bt_logging_connection(FALSE, addr_type);
1884 /*Check for any OPP transfer on the device and cancel
1887 _bt_obex_check_pending_transfer(address);
1888 _bt_opp_client_is_sending(&sending);
1890 _bt_opp_client_check_pending_transfer(address);
1892 _bt_send_event(BT_DEVICE_EVENT,
1893 BLUETOOTH_EVENT_DEVICE_DISCONNECTED,
1894 DBUS_TYPE_INT32, &result,
1895 DBUS_TYPE_STRING, &address,
1896 DBUS_TYPE_BYTE, &addr_type,
1900 } else if (strcasecmp(member, "ProfileStateChanged") == 0) {
1902 char *profile_uuid = NULL;
1903 bt_headset_wait_t *wait_list;
1905 if (!dbus_message_get_args(msg, NULL,
1906 DBUS_TYPE_STRING, &profile_uuid,
1907 DBUS_TYPE_INT32, &state,
1908 DBUS_TYPE_INVALID)) {
1911 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1913 _bt_convert_device_path_to_address(path, address);
1915 BT_DBG("Address: %s", address);
1916 BT_DBG("Profile UUID: %s", profile_uuid);
1917 BT_DBG("State: %d", state);
1919 if ((strcmp(profile_uuid, A2DP_SINK_UUID) == 0) &&
1920 (state == BT_PROFILE_STATE_CONNECTED)) {
1922 int event = BLUETOOTH_EVENT_AV_CONNECTED;
1923 char connected_address[BT_ADDRESS_STRING_SIZE + 1];
1924 bluetooth_device_address_t device_address;
1926 bt_headset_wait_t *wait_list;
1928 __bt_set_device_values(TRUE,
1929 VCONFKEY_BT_DEVICE_A2DP_HEADSET_CONNECTED);
1931 __bt_connection_manager_set_state(address, event);
1933 if (_bt_headset_get_local_connection() == FALSE)
1934 _bt_start_timer_for_connection(address, BT_AUDIO_HSP);
1936 /* Connection Started from local device therefore no need to
1937 * intiate connection for pending profile */
1938 _bt_headset_set_local_connection(FALSE);
1941 _bt_send_event(BT_HEADSET_EVENT, event,
1942 DBUS_TYPE_INT32, &result,
1943 DBUS_TYPE_STRING, &address,
1946 connected = _bt_is_headset_type_connected(BT_AUDIO_A2DP,
1949 if (g_strcmp0(connected_address, address) != 0) {
1950 _bt_convert_addr_string_to_type(
1951 device_address.addr,
1953 _bt_audio_disconnect(0, BT_AUDIO_A2DP,
1954 &device_address, NULL);
1958 _bt_add_headset_to_list(BT_AUDIO_A2DP,
1959 BT_STATE_CONNECTED, address);
1961 wait_list = _bt_get_audio_wait_data();
1962 if (wait_list != NULL &&
1963 (g_strcmp0(wait_list->address, address) == 0))
1964 _bt_rel_wait_data();
1966 } else if ((strcmp(profile_uuid, A2DP_SINK_UUID) == 0) &&
1967 (state == BT_PROFILE_STATE_DISCONNECTED)) {
1969 int event = BLUETOOTH_EVENT_AV_DISCONNECTED;
1971 if (!_bt_is_service_connected(address, BT_AUDIO_A2DP)) {
1976 __bt_set_device_values(FALSE,
1977 VCONFKEY_BT_DEVICE_A2DP_HEADSET_CONNECTED);
1979 __bt_connection_manager_set_state(address, event);
1981 _bt_send_event(BT_HEADSET_EVENT, event,
1982 DBUS_TYPE_INT32, &result,
1983 DBUS_TYPE_STRING, &address,
1986 /* Remove data from the connected list */
1987 _bt_remove_headset_from_list(BT_AUDIO_A2DP, address);
1988 wait_list = _bt_get_audio_wait_data();
1990 if (wait_list == NULL) {
1995 if (((wait_list->type == BT_AUDIO_ALL) &&
1996 (wait_list->ag_flag == TRUE)) ||
1997 (wait_list->type == BT_AUDIO_A2DP) ||
1998 (wait_list->disconnection_type == BT_AUDIO_A2DP)) {
1999 bluetooth_device_address_t device_address;
2000 _bt_convert_addr_string_to_type(
2001 device_address.addr,
2002 wait_list->address);
2004 _bt_audio_connect(wait_list->req_id,
2007 wait_list->out_param1);
2009 } else if (strcmp(profile_uuid, AVRCP_TARGET_UUID) == 0) {
2011 if (state == BT_PROFILE_STATE_CONNECTED) {
2012 int event = BLUETOOTH_EVENT_AVRCP_CONTROL_CONNECTED;
2013 char connected_address[BT_ADDRESS_STRING_SIZE + 1];
2014 bluetooth_device_address_t device_address;
2017 _bt_send_event(BT_AVRCP_CONTROL_EVENT, event,
2018 DBUS_TYPE_INT32, &result,
2019 DBUS_TYPE_STRING, &address,
2021 connected = _bt_is_headset_type_connected(
2025 if (g_strcmp0(connected_address,
2027 _bt_convert_addr_string_to_type(
2028 device_address.addr,
2030 _bt_audio_disconnect(0,
2032 &device_address, NULL);
2035 BT_DBG("device Path: %s", path);
2036 _bt_add_headset_to_list(BT_AVRCP,
2037 BT_STATE_CONNECTED, address);
2038 } else if (state == BT_PROFILE_STATE_DISCONNECTED) {
2039 int event = BLUETOOTH_EVENT_AVRCP_CONTROL_DISCONNECTED;
2041 _bt_send_event(BT_AVRCP_CONTROL_EVENT, event,
2042 DBUS_TYPE_INT32, &result,
2043 DBUS_TYPE_STRING, &address,
2046 /* Remove data from the connected list */
2047 _bt_remove_headset_from_list(BT_AVRCP, address);
2049 } else if ((strcmp(profile_uuid, HID_UUID) == 0) &&
2050 ((state == BT_PROFILE_STATE_CONNECTED) ||
2051 (state == BT_PROFILE_STATE_DISCONNECTED))) {
2053 if (state == BT_PROFILE_STATE_CONNECTED)
2054 event = BLUETOOTH_HID_CONNECTED;
2056 event = BLUETOOTH_HID_DISCONNECTED;
2058 _bt_send_event(BT_HID_EVENT, event,
2059 DBUS_TYPE_INT32, &result,
2060 DBUS_TYPE_STRING, &address,
2064 } else if (strcasecmp(member, "AdvReport") == 0) {
2066 bt_remote_le_dev_info_t *le_dev_info = NULL;
2067 char *buffer = NULL;
2069 bt_le_adv_info_t *adv_info = NULL;
2071 ret_if(_bt_is_le_discovering() == FALSE);
2073 le_dev_info = g_malloc0(sizeof(bt_remote_le_dev_info_t));
2075 if (!dbus_message_get_args(msg, NULL,
2076 DBUS_TYPE_STRING, &le_dev_info->address,
2077 DBUS_TYPE_BYTE, &le_dev_info->addr_type,
2078 DBUS_TYPE_BYTE, &le_dev_info->adv_type,
2079 DBUS_TYPE_INT32, &le_dev_info->rssi,
2080 DBUS_TYPE_INT32, &le_dev_info->adv_data_len,
2081 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &buffer, &buffer_len,
2082 DBUS_TYPE_INVALID)) {
2083 g_free(le_dev_info);
2087 le_dev_info->adv_data = g_memdup(buffer, buffer_len);
2089 if (_bt_get_le_discovery_type() == BT_LE_PASSIVE_SCAN) {
2091 _bt_send_event(BT_LE_ADAPTER_EVENT,
2092 BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND,
2093 DBUS_TYPE_INT32, &result,
2094 DBUS_TYPE_STRING, &le_dev_info->address,
2095 DBUS_TYPE_INT16, &le_dev_info->addr_type,
2096 DBUS_TYPE_INT16, &le_dev_info->rssi,
2097 DBUS_TYPE_INT16, &le_dev_info->adv_data_len,
2098 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
2099 &le_dev_info->adv_data, le_dev_info->adv_data_len,
2100 DBUS_TYPE_INT16, &len,
2101 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
2102 &le_dev_info->adv_data, len,
2104 _bt_free_le_device_info(le_dev_info);
2108 if (le_dev_info->adv_type != BT_LE_ADV_SCAN_RSP) { /* ADV_IND */
2109 adv_info = g_malloc0(sizeof(bt_le_adv_info_t));
2110 adv_info->addr = g_strdup(le_dev_info->address);
2111 adv_info->data_len = le_dev_info->adv_data_len;
2112 adv_info->data = g_malloc0(le_dev_info->adv_data_len);
2113 memcpy(adv_info->data, le_dev_info->adv_data,
2114 le_dev_info->adv_data_len);
2116 __bt_add_adv_ind_info(adv_info);
2118 } else { /* SCAN_RSP */
2119 adv_info = __bt_get_adv_ind_info(le_dev_info->address);
2121 _bt_send_event(BT_LE_ADAPTER_EVENT,
2122 BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND,
2123 DBUS_TYPE_INT32, &result,
2124 DBUS_TYPE_STRING, &le_dev_info->address,
2125 DBUS_TYPE_INT16, &le_dev_info->addr_type,
2126 DBUS_TYPE_INT16, &le_dev_info->rssi,
2127 DBUS_TYPE_INT16, &adv_info->data_len,
2128 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
2129 &adv_info->data, adv_info->data_len,
2130 DBUS_TYPE_INT16, &le_dev_info->adv_data_len,
2131 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
2132 &le_dev_info->adv_data, le_dev_info->adv_data_len,
2134 __bt_del_adv_ind_info(le_dev_info->address);
2137 _bt_free_le_device_info(le_dev_info);
2141 void __bt_set_audio_values(gboolean connected, char *address)
2144 int bt_device_state = VCONFKEY_BT_DEVICE_NONE;
2146 /* Set the headset name */
2147 if (connected == TRUE) {
2148 name = __bt_get_headset_name(address);
2150 name = g_strdup("");
2153 if (vconf_set_str(VCONFKEY_BT_HEADSET_NAME,
2155 BT_ERR("vconf_set_str failed");
2160 /* Set the headset state */
2161 if (vconf_get_int(VCONFKEY_BT_DEVICE,
2162 &bt_device_state) != 0) {
2163 BT_ERR("vconf_get_str failed");
2166 #ifdef TIZEN_SUPPORT_DUAL_HF
2167 if ((connected == TRUE) &&
2168 (FALSE == __bt_is_companion_device(address))) {
2169 bt_device_state |= VCONFKEY_BT_DEVICE_HEADSET_CONNECTED;
2170 } else if ((bt_device_state & VCONFKEY_BT_DEVICE_HEADSET_CONNECTED) &&
2171 (FALSE == __bt_is_companion_device(address))) {
2172 bt_device_state ^= VCONFKEY_BT_DEVICE_HEADSET_CONNECTED;
2175 if (connected == TRUE) {
2176 bt_device_state |= VCONFKEY_BT_DEVICE_HEADSET_CONNECTED;
2177 } else if (bt_device_state & VCONFKEY_BT_DEVICE_HEADSET_CONNECTED) {
2178 bt_device_state ^= VCONFKEY_BT_DEVICE_HEADSET_CONNECTED;
2182 if (vconf_set_int(VCONFKEY_BT_DEVICE,
2183 bt_device_state) != 0) {
2184 BT_ERR("vconf_set_int failed");
2188 void _bt_handle_headset_event(DBusMessage *msg)
2190 int result = BLUETOOTH_ERROR_NONE;
2191 DBusMessageIter item_iter;
2192 DBusMessageIter value_iter;
2193 gboolean property_flag = FALSE;
2194 const char *member = dbus_message_get_member(msg);
2195 const char *path = dbus_message_get_path(msg);
2196 const char *property = NULL;
2198 ret_if(member == NULL);
2200 dbus_message_iter_init(msg, &item_iter);
2202 if (dbus_message_iter_get_arg_type(&item_iter)
2203 != DBUS_TYPE_STRING) {
2204 BT_ERR("This is bad format dbus");
2208 dbus_message_iter_get_basic(&item_iter, &property);
2210 ret_if(property == NULL);
2212 BT_DBG("Property = %s \n", property);
2214 /* We allow only 1 headset connection (HSP or HFP)*/
2215 if (strcasecmp(property, "Connected") == 0) {
2216 int event = BLUETOOTH_EVENT_NONE;
2217 bt_headset_wait_t *wait_list;
2220 dbus_message_iter_next(&item_iter);
2221 dbus_message_iter_recurse(&item_iter, &value_iter);
2222 dbus_message_iter_get_basic(&value_iter, &property_flag);
2224 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
2226 _bt_convert_device_path_to_address(path, address);
2228 if (property_flag == TRUE) {
2229 event = BLUETOOTH_EVENT_AG_CONNECTED;
2230 if (_bt_headset_get_local_connection() == FALSE)
2231 _bt_start_timer_for_connection(address, BT_AUDIO_A2DP);
2233 _bt_headset_set_local_connection(FALSE);
2237 event = BLUETOOTH_EVENT_AG_DISCONNECTED;
2239 previous_state = _bt_get_device_state_from_list(BT_AUDIO_HSP, address);
2240 if (previous_state == BT_STATE_DISCONNECTING)
2241 _bt_send_hf_local_term_event(address);
2243 /* Set the State machine here */
2244 __bt_connection_manager_set_state(address, event);
2245 __bt_set_audio_values(property_flag, address);
2247 _bt_send_event(BT_HEADSET_EVENT, event,
2248 DBUS_TYPE_INT32, &result,
2249 DBUS_TYPE_STRING, &address,
2252 if (event == BLUETOOTH_EVENT_AG_DISCONNECTED) {
2253 /* Remove data from the connected list */
2254 _bt_remove_headset_from_list(BT_AUDIO_HSP, address);
2256 wait_list = _bt_get_audio_wait_data();
2257 if (wait_list == NULL) {
2262 bluetooth_device_address_t device_address;
2264 _bt_set_audio_wait_data_flag(TRUE);
2266 _bt_convert_addr_string_to_type(device_address.addr,
2267 wait_list->address);
2268 _bt_audio_connect(wait_list->req_id, wait_list->type,
2269 &device_address, wait_list->out_param1);
2270 _bt_rel_wait_data();
2271 } else if (event == BLUETOOTH_EVENT_AG_CONNECTED) {
2272 /* Add data to the connected list */
2273 _bt_add_headset_to_list(BT_AUDIO_HSP,
2274 BT_STATE_CONNECTED, address);
2276 wait_list = _bt_get_audio_wait_data();
2277 if (wait_list != NULL &&
2278 (g_strcmp0(wait_list->address, address) == 0))
2279 _bt_rel_wait_data();
2281 BT_INFO("Check A2DP pending connect");
2282 _bt_audio_check_pending_connect();
2285 } else if (strcasecmp(property, "State") == 0) {
2288 dbus_message_iter_next(&item_iter);
2289 dbus_message_iter_recurse(&item_iter, &value_iter);
2290 dbus_message_iter_get_basic(&value_iter, &state);
2292 /* This code assumes we support only 1 headset connection */
2293 /* Need to use the headset list, if we support multi-headsets */
2294 if (strcasecmp(state, "Playing") == 0) {
2295 BT_DBG("Playing: Sco Connected");
2296 } else if (strcasecmp(state, "connected") == 0 ||
2297 strcasecmp(state, "disconnected") == 0) {
2298 BT_DBG("connected/disconnected: Sco Disconnected");
2300 BT_ERR("Not handled state - %s", state);
2303 } else if (strcasecmp(property, "SpeakerGain") == 0) {
2307 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
2309 _bt_convert_device_path_to_address(path, address);
2311 dbus_message_iter_next(&item_iter);
2312 dbus_message_iter_recurse(&item_iter, &value_iter);
2313 dbus_message_iter_get_basic(&value_iter, &spkr_gain);
2315 _bt_send_event(BT_HEADSET_EVENT, BLUETOOTH_EVENT_AG_SPEAKER_GAIN,
2316 DBUS_TYPE_INT32, &result,
2317 DBUS_TYPE_STRING, &address,
2318 DBUS_TYPE_UINT16, &spkr_gain,
2322 } else if (strcasecmp(property, "MicrophoneGain") == 0) {
2326 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
2328 _bt_convert_device_path_to_address(path, address);
2330 dbus_message_iter_next(&item_iter);
2331 dbus_message_iter_recurse(&item_iter, &value_iter);
2332 dbus_message_iter_get_basic(&value_iter, &mic_gain);
2334 _bt_send_event(BT_HEADSET_EVENT, BLUETOOTH_EVENT_AG_MIC_GAIN,
2335 DBUS_TYPE_INT32, &result,
2336 DBUS_TYPE_STRING, &address,
2337 DBUS_TYPE_UINT16, &mic_gain,
2344 void _bt_handle_sink_event(DBusMessage *msg)
2346 int result = BLUETOOTH_ERROR_NONE;
2347 DBusMessageIter item_iter;
2348 DBusMessageIter value_iter;
2349 const char *member = dbus_message_get_member(msg);
2350 const char *path = dbus_message_get_path(msg);
2351 const char *property = NULL;
2353 bt_headset_wait_t *wait_list;
2355 ret_if(member == NULL);
2357 dbus_message_iter_init(msg, &item_iter);
2359 if (dbus_message_iter_get_arg_type(&item_iter)
2360 != DBUS_TYPE_STRING) {
2361 BT_ERR("This is bad format dbus");
2365 dbus_message_iter_get_basic(&item_iter, &property);
2367 ret_if(property == NULL);
2369 BT_DBG("Property: %s", property);
2371 if (strcasecmp(property, "State") == 0) {
2375 dbus_message_iter_next(&item_iter);
2376 dbus_message_iter_recurse(&item_iter, &value_iter);
2377 dbus_message_iter_get_basic(&value_iter, &value);
2379 BT_DBG("value: %s", value);
2381 if (g_strcmp0(value, "disconnected") == 0) {
2384 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
2386 _bt_convert_device_path_to_address(path, address);
2388 __bt_set_device_values(FALSE,
2389 VCONFKEY_BT_DEVICE_A2DP_HEADSET_CONNECTED);
2391 _bt_send_event(BT_HEADSET_EVENT,
2392 BLUETOOTH_EVENT_AV_DISCONNECTED,
2393 DBUS_TYPE_INT32, &result,
2394 DBUS_TYPE_STRING, &address,
2397 /* Remove data from the connected list */
2398 _bt_remove_headset_from_list(BT_AUDIO_A2DP, address);
2399 wait_list = _bt_get_audio_wait_data();
2400 if (wait_list == NULL) {
2405 if (((wait_list->type == BT_AUDIO_ALL) &&
2406 (wait_list->ag_flag == TRUE)) ||
2407 (wait_list->type == BT_AUDIO_A2DP) ||
2408 (wait_list->disconnection_type == BT_AUDIO_A2DP)) {
2409 bluetooth_device_address_t device_address;
2410 _bt_convert_addr_string_to_type(
2411 device_address.addr,
2412 wait_list->address);
2414 _bt_audio_connect(wait_list->req_id,
2417 wait_list->out_param1);
2420 }else if (strcasecmp(value, "Connected") == 0) {
2422 char connected_address[BT_ADDRESS_STRING_SIZE + 1];
2423 bluetooth_device_address_t device_address;
2426 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
2428 _bt_convert_device_path_to_address(path, address);
2430 __bt_set_device_values(TRUE,
2431 VCONFKEY_BT_DEVICE_A2DP_HEADSET_CONNECTED);
2433 _bt_send_event(BT_HEADSET_EVENT,
2434 BLUETOOTH_EVENT_AV_CONNECTED,
2435 DBUS_TYPE_INT32, &result,
2436 DBUS_TYPE_STRING, &address,
2439 /* Check for existing Media device to disconnect */
2440 connected = _bt_is_headset_type_connected(BT_AUDIO_A2DP,
2443 /* Match connected device address */
2444 if (g_strcmp0(connected_address, address) != 0) {
2445 /* Convert BD adress from string type */
2446 _bt_convert_addr_string_to_type(
2447 device_address.addr,
2449 _bt_audio_disconnect(0, BT_AUDIO_A2DP,
2450 &device_address, NULL);
2454 /* Add data to the connected list */
2455 _bt_add_headset_to_list(BT_AUDIO_A2DP,
2456 BT_STATE_CONNECTED, address);
2463 void _bt_handle_agent_event(DBusMessage *msg)
2465 const char *member = dbus_message_get_member(msg);
2466 int result = BLUETOOTH_ERROR_NONE;
2467 char *address = NULL;
2471 ret_if(member == NULL);
2473 if (strcasecmp(member, "ObexAuthorize") == 0) {
2474 __bt_get_agent_signal_info(msg, &address, &name, &uuid);
2476 _bt_send_event(BT_OPP_SERVER_EVENT,
2477 BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE,
2478 DBUS_TYPE_INT32, &result,
2479 DBUS_TYPE_STRING, &address,
2480 DBUS_TYPE_STRING, &name,
2482 } else if (strcasecmp(member, "RfcommAuthorize") == 0) {
2483 bt_rfcomm_server_info_t *server_info;
2485 __bt_get_agent_signal_info(msg, &address, &name, &uuid);
2487 server_info = _bt_rfcomm_get_server_info_using_uuid(uuid);
2488 ret_if(server_info == NULL);
2489 ret_if(server_info->server_type != BT_CUSTOM_SERVER);
2491 _bt_send_event(BT_RFCOMM_SERVER_EVENT,
2492 BLUETOOTH_EVENT_RFCOMM_AUTHORIZE,
2493 DBUS_TYPE_INT32, &result,
2494 DBUS_TYPE_STRING, &address,
2495 DBUS_TYPE_STRING, &uuid,
2496 DBUS_TYPE_STRING, &name,
2497 DBUS_TYPE_INT16, &server_info->control_fd,
2502 static int __bt_get_object_path(DBusMessage *msg, char **path)
2504 DBusMessageIter item_iter;
2506 dbus_message_iter_init(msg, &item_iter);
2508 if (dbus_message_iter_get_arg_type(&item_iter)
2509 != DBUS_TYPE_OBJECT_PATH) {
2510 BT_ERR("This is bad format dbus");
2511 return BLUETOOTH_ERROR_INTERNAL;
2514 dbus_message_iter_get_basic(&item_iter, path);
2517 return BLUETOOTH_ERROR_INTERNAL;
2519 return BLUETOOTH_ERROR_NONE;
2522 static int __bt_parse_event(DBusMessage *msg)
2524 DBusMessageIter msg_iter;
2525 DBusMessageIter value_iter;
2527 retv_if(dbus_message_iter_init(msg, &msg_iter) == FALSE, 0);
2529 /* object array (oa) */
2530 retv_if(dbus_message_iter_next(&msg_iter) == FALSE, 0);
2531 retv_if(dbus_message_iter_get_arg_type(&msg_iter) !=
2532 DBUS_TYPE_ARRAY, 0);
2534 dbus_message_iter_recurse(&msg_iter, &value_iter);
2536 /* string array (sa) */
2537 while (dbus_message_iter_get_arg_type(&value_iter) ==
2538 DBUS_TYPE_DICT_ENTRY) {
2539 char *interface_name = NULL;
2540 DBusMessageIter interface_iter;
2542 dbus_message_iter_recurse(&value_iter, &interface_iter);
2544 retv_if(dbus_message_iter_get_arg_type(&interface_iter) !=
2545 DBUS_TYPE_STRING, 0);
2547 dbus_message_iter_get_basic(&interface_iter,
2550 retv_if(dbus_message_iter_next(&interface_iter) == FALSE,
2553 retv_if(dbus_message_iter_get_arg_type(&interface_iter) !=
2554 DBUS_TYPE_ARRAY, 0);
2556 BT_DBG("interface: %s", interface_name);
2558 if (g_strcmp0(interface_name,
2559 BT_DEVICE_INTERFACE) == 0) {
2560 return BT_DEVICE_EVENT;
2561 } else if (g_strcmp0(interface_name,
2562 BT_MEDIATRANSPORT_INTERFACE) == 0) {
2563 return BT_MEDIA_TRANSFER_EVENT;
2564 } else if (g_strcmp0(interface_name,
2565 BT_PLAYER_CONTROL_INTERFACE) == 0) {
2566 return BT_AVRCP_CONTROL_EVENT;
2568 dbus_message_iter_next(&value_iter);
2574 static int __bt_parse_remove_event(DBusMessage *msg)
2576 DBusMessageIter msg_iter;
2577 DBusMessageIter value_iter;
2579 retv_if(dbus_message_iter_init(msg, &msg_iter) ==
2582 retv_if(dbus_message_iter_next(&msg_iter) == FALSE,
2584 retv_if(dbus_message_iter_get_arg_type(&msg_iter) !=
2585 DBUS_TYPE_ARRAY, 0);
2587 dbus_message_iter_recurse(&msg_iter, &value_iter);
2589 while (dbus_message_iter_get_arg_type(&value_iter)
2590 != DBUS_TYPE_INVALID) {
2593 dbus_message_iter_get_basic(&value_iter, &key);
2596 dbus_message_iter_next(&value_iter);
2600 BT_DBG("key = %s", key);
2602 if (g_strcmp0(key, BT_MEDIATRANSPORT_INTERFACE) == 0) {
2603 return BT_MEDIA_TRANSFER_EVENT;
2604 } else if (g_strcmp0(key, BT_DEVICE_INTERFACE) == 0) {
2605 return BT_DEVICE_EVENT;
2606 } else if (g_strcmp0(key, BT_PLAYER_CONTROL_INTERFACE) == 0) {
2607 return BT_AVRCP_CONTROL_EVENT;
2609 dbus_message_iter_next(&value_iter);
2615 static void __bt_devices_list_free(void)
2617 bt_cache_info_t *cache_info;
2620 node = g_list_first(p_cache_list);
2622 while (node != NULL){
2623 cache_info = (bt_cache_info_t *)node->data;
2625 p_cache_list = g_list_remove(p_cache_list, cache_info);
2626 __bt_free_cache_info(cache_info);
2628 node = g_list_next(node);
2632 static DBusHandlerResult __bt_manager_event_filter(DBusConnection *conn,
2633 DBusMessage *msg, void *data)
2635 const char *member = dbus_message_get_member(msg);
2636 bt_event_type_t bt_event;
2637 int result = BLUETOOTH_ERROR_NONE;
2639 if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
2640 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2642 retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
2644 if (strcasecmp(member, "InterfacesAdded") == 0) {
2645 char *object_path = NULL;
2647 BT_DBG("InterfacesAdded");
2649 if (__bt_get_object_path(msg, &object_path)) {
2650 BT_ERR("Fail to get the path");
2651 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2654 if (strcasecmp(object_path, BT_BLUEZ_HCI_PATH) == 0) {
2655 _bt_handle_adapter_added();
2657 bt_event = __bt_parse_event(msg);
2658 if (bt_event == BT_DEVICE_EVENT) {
2659 bt_cache_info_t *cache_info;
2660 bt_remote_dev_info_t *dev_info;
2662 retv_if(_bt_is_discovering() == FALSE &&
2663 _bt_is_le_discovering() == FALSE,
2664 DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
2666 cache_info = g_malloc0(sizeof(bt_cache_info_t));
2667 dev_info = g_malloc0(sizeof(bt_remote_dev_info_t));
2668 cache_info->dev_info = dev_info;
2670 if (__bt_parse_interface(msg, dev_info) == FALSE) {
2671 BT_ERR("Fail to parse the properies");
2672 __bt_free_cache_info(cache_info);
2673 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2676 if (dev_info->addr_type != BDADDR_BREDR) {
2677 /* Whenever emit the property changed from bluez,
2678 some property doesn't reach to bt-service.
2679 So LE device is handled as AdvReport signal */
2680 __bt_free_cache_info(cache_info);
2681 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2684 if (dev_info->name == NULL)
2685 /* If Remote device name is NULL or still RNR is not done
2686 * then display address as name.
2688 dev_info->name = g_strdup(dev_info->address);
2690 _bt_send_event(BT_ADAPTER_EVENT,
2691 BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND,
2692 DBUS_TYPE_INT32, &result,
2693 DBUS_TYPE_STRING, &dev_info->address,
2694 DBUS_TYPE_UINT32, &dev_info->class,
2695 DBUS_TYPE_INT16, &dev_info->rssi,
2696 DBUS_TYPE_STRING, &dev_info->name,
2697 DBUS_TYPE_BOOLEAN, &dev_info->paired,
2698 DBUS_TYPE_BOOLEAN, &dev_info->connected,
2699 DBUS_TYPE_BOOLEAN, &dev_info->trust,
2700 DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
2701 &dev_info->uuids, dev_info->uuid_count,
2702 DBUS_TYPE_INT16, &dev_info->manufacturer_data_len,
2703 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
2704 &dev_info->manufacturer_data, dev_info->manufacturer_data_len,
2707 p_cache_list = g_list_append(p_cache_list, cache_info);
2708 } else if (bt_event == BT_AVRCP_CONTROL_EVENT) {
2709 BT_DBG("Device path : %s ", object_path);
2710 _bt_set_control_device_path(object_path);
2713 } else if (strcasecmp(member, "InterfacesRemoved") == 0) {
2714 bt_event = __bt_parse_remove_event(msg);
2716 if ((bt_event != 0) && (bt_event != BT_MEDIA_TRANSFER_EVENT)) {
2717 _bt_handle_adapter_event(msg);
2718 if (bt_event == BT_AVRCP_CONTROL_EVENT) {
2719 char *object_path = NULL;
2720 result = __bt_get_object_path(msg, &object_path);
2721 if (result == BLUETOOTH_ERROR_NONE)
2722 _bt_remove_control_device_path(object_path);
2726 } else if (strcasecmp(member, "NameOwnerChanged") == 0) {
2729 char *previous = NULL;
2730 char *current = NULL;
2732 if (__bt_get_owner_info(msg, &name, &previous, ¤t)) {
2733 BT_ERR("Fail to get the owner info");
2734 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2737 if (*current != '\0')
2738 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2740 if (strcasecmp(name, BT_BLUEZ_NAME) == 0) {
2741 BT_DBG("Bluetoothd is terminated");
2742 if (_bt_adapter_get_status() != BT_DEACTIVATING) {
2745 _bt_handle_adapter_removed();
2746 __bt_devices_list_free();
2749 _bt_obex_server_check_allocation(&value);
2751 if (value == TRUE) {
2752 /* Check if the obex server was terminated abnormally */
2753 _bt_obex_server_check_termination(name);
2756 _bt_rfcomm_server_check_existence(&value);
2758 if (value == TRUE) {
2759 /* The obex server was terminated abnormally */
2760 _bt_rfcomm_server_check_termination(name);
2763 /* Stop advertising started by terminated process */
2764 _bt_stop_advertising_by_terminated_process(name);
2765 } else if (dbus_message_has_interface(msg, BT_PROPERTIES_INTERFACE)) {
2766 const char *path = dbus_message_get_path(msg);
2768 if (strncmp(path, BT_MEDIA_OBJECT_PATH,
2769 strlen(BT_MEDIA_OBJECT_PATH)) == 0)
2770 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2772 _bt_handle_property_changed_event(msg);
2773 } else if (dbus_message_has_interface(msg, BT_ADAPTER_INTERFACE)) {
2774 _bt_handle_adapter_event(msg);
2775 } else if (dbus_message_has_interface(msg, BT_INPUT_INTERFACE)) {
2776 _bt_handle_input_event(msg);
2777 } else if (dbus_message_has_interface(msg, BT_NETWORK_SERVER_INTERFACE)) {
2778 _bt_handle_network_server_event(msg);
2779 } else if (dbus_message_has_interface(msg, BT_HEADSET_INTERFACE)) {
2780 _bt_handle_headset_event(msg);
2781 } else if (dbus_message_has_interface(msg, BT_SINK_INTERFACE)) {
2782 _bt_handle_sink_event(msg);
2783 } else if (dbus_message_has_interface(msg, BT_AGENT_INTERFACE)) {
2784 _bt_handle_agent_event(msg);
2785 } else if (dbus_message_has_interface(msg, BT_DEVICE_INTERFACE)) {
2786 _bt_handle_device_event(msg);
2789 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2792 static gboolean __bt_is_obexd_event(DBusMessage *msg)
2794 const char *member = dbus_message_get_member(msg);
2796 if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
2799 retv_if(member == NULL, FALSE);
2801 if (dbus_message_has_interface(msg, BT_PROPERTIES_INTERFACE)) {
2803 DBusMessageIter item_iter;
2804 const char *interface_name = NULL;
2806 dbus_message_iter_init(msg, &item_iter);
2808 if (dbus_message_iter_get_arg_type(&item_iter)
2809 != DBUS_TYPE_STRING) {
2810 BT_ERR("This is bad format dbus");
2814 dbus_message_iter_get_basic(&item_iter, &interface_name);
2816 retv_if(interface_name == NULL, FALSE);
2818 BT_DBG("interface: %s", interface_name);
2820 retv_if(dbus_message_iter_next(&item_iter) == FALSE, FALSE);
2822 retv_if(dbus_message_iter_get_arg_type(&item_iter) != DBUS_TYPE_ARRAY,
2825 if (strcasecmp(interface_name, BT_OBEX_TRANSFER_INTERFACE) == 0) {
2826 BT_DBG("BT_OBEX_TRANSFER_INTERFACE");
2834 static DBusHandlerResult __bt_obexd_event_filter(DBusConnection *conn,
2835 DBusMessage *msg, void *data)
2837 const char *member = dbus_message_get_member(msg);
2838 char *object_path = NULL;
2840 if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
2841 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2843 retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
2845 if (strcasecmp(member, "InterfacesAdded") == 0) {
2846 BT_DBG("InterfacesAdded");
2847 if (__bt_get_object_path(msg, &object_path)) {
2848 BT_ERR("Fail to get the path");
2849 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2852 BT_INFO("object_path = [%s]", object_path);
2854 /*Handle OPP_SERVER_CONNECTED_EVENT here */
2855 if (strncmp(object_path, BT_SESSION_BASEPATH_SERVER,
2856 strlen(BT_SESSION_BASEPATH_SERVER)) != 0)
2857 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2859 if (g_strrstr(object_path, "session") && g_strrstr(object_path, "transfer")) {
2860 BT_DBG("Obex_Server_Session_Transfer connected");
2861 _bt_obex_transfer_connected();
2863 } else if (strcasecmp(member, "InterfacesRemoved") == 0) {
2864 /*Handle OPP_SERVER_DISCONNECTED_EVENT here */
2865 BT_DBG("InterfacesRemoved");
2866 if (__bt_get_object_path(msg, &object_path)) {
2867 BT_ERR("Fail to get the path");
2868 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2871 BT_INFO("object_path = [%s]", object_path);
2873 if (strncmp(object_path, BT_SESSION_BASEPATH_SERVER,
2874 strlen(BT_SESSION_BASEPATH_SERVER)) != 0)
2875 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2877 if (g_strrstr(object_path, "session") && g_strrstr(object_path, "transfer")) {
2878 BT_DBG("Obex_Server_Session_Transfer disconnected");
2879 _bt_obex_transfer_disconnected();
2881 } else if (__bt_is_obexd_event(msg) == TRUE) {
2882 const char *path = dbus_message_get_path(msg);
2884 if (strncmp(path, BT_SESSION_BASEPATH_SERVER,
2885 strlen(BT_SESSION_BASEPATH_SERVER)) != 0 &&
2886 strncmp(path, BT_SESSION_BASEPATH_CLIENT,
2887 strlen(BT_SESSION_BASEPATH_CLIENT)) != 0) {
2888 BT_DBG("DBUS_HANDLER_RESULT_NOT_YET_HANDLED");
2889 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2892 _bt_handle_property_changed_event(msg);
2894 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2897 static gboolean __bt_is_obexd_client_event(DBusMessage *msg)
2901 const char *member = dbus_message_get_member(msg);
2903 if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
2906 retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
2908 if (dbus_message_has_interface(msg, BT_PROPERTIES_INTERFACE)) {
2909 DBusMessageIter item_iter;
2910 const char *interface_name = NULL;
2912 dbus_message_iter_init(msg, &item_iter);
2914 if (dbus_message_iter_get_arg_type(&item_iter)
2915 != DBUS_TYPE_STRING) {
2916 BT_ERR("This is bad format dbus");
2920 dbus_message_iter_get_basic(&item_iter, &interface_name);
2922 retv_if(interface_name == NULL, FALSE);
2924 BT_DBG("interface: %s", interface_name);
2926 retv_if(dbus_message_iter_next(&item_iter) == FALSE,
2929 retv_if(dbus_message_iter_get_arg_type(&item_iter)
2930 != DBUS_TYPE_ARRAY, FALSE);
2932 if (strcasecmp(interface_name,
2933 BT_OBEX_TRANSFER_INTERFACE) == 0) {
2944 static DBusHandlerResult __bt_opc_event_filter(DBusConnection *conn,
2945 DBusMessage *msg, void *data)
2947 const char *member = dbus_message_get_member(msg);
2949 if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
2950 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2952 retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
2954 if (strcasecmp(member, "InterfacesAdded") == 0) {
2955 BT_DBG("InterfacesAdded");
2956 }else if (strcasecmp(member, "InterfacesRemoved") == 0) {
2957 char *object_path = NULL;
2959 BT_DBG("InterfacesRemoved");
2961 if (__bt_get_object_path(msg, &object_path)) {
2962 BT_ERR("Fail to get the path");
2963 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2966 BT_DBG("object_path =%s",object_path);
2968 if (strncmp(object_path, BT_SESSION_BASEPATH_CLIENT,
2969 strlen(BT_SESSION_BASEPATH_CLIENT)) != 0
2970 || strstr(object_path, "transfer") == NULL)
2971 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2972 else if (strncmp(object_path, BT_SESSION_BASEPATH_CLIENT,
2973 strlen(BT_SESSION_BASEPATH_CLIENT)) == 0) {
2974 BT_DBG("Going to call opc disconnected");
2975 _bt_opc_disconnected(object_path);
2978 _bt_sending_files();
2980 }else if (__bt_is_obexd_client_event(msg) == TRUE){
2981 const char *path = dbus_message_get_path(msg);
2983 if (strncmp(path, BT_SESSION_BASEPATH_CLIENT,
2984 strlen(BT_SESSION_BASEPATH_CLIENT)) != 0) {
2985 BT_DBG("NOT BT_SESSION_BASEPATH_CLIENT");
2986 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2989 _bt_opc_property_changed_event(msg);
2992 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2995 int _bt_opp_client_event_init(void)
2997 GError *error = NULL;
2999 if (opc_obexd_conn == NULL) {
3000 opc_obexd_conn = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
3001 if (error != NULL) {
3002 BT_ERR("ERROR: Can't get on session bus [%s]",
3004 g_error_free(error);
3005 return BLUETOOTH_ERROR_INTERNAL;
3008 retv_if(opc_obexd_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
3011 if (_bt_register_service_event(opc_obexd_conn,
3012 BT_OPP_CLIENT_EVENT) != BLUETOOTH_ERROR_NONE) {
3013 dbus_g_connection_unref(opc_obexd_conn);
3014 opc_obexd_conn = NULL;
3015 return BLUETOOTH_ERROR_INTERNAL;
3018 return BLUETOOTH_ERROR_NONE;
3021 void _bt_opp_client_event_deinit(void)
3023 if (opc_obexd_conn) {
3024 _bt_unregister_service_event(opc_obexd_conn,
3025 BT_OPP_CLIENT_EVENT);
3026 dbus_g_connection_unref(opc_obexd_conn);
3027 opc_obexd_conn = NULL;
3031 int _bt_register_service_event(DBusGConnection *g_conn, int event_type)
3035 DBusError dbus_error;
3036 char *match1 = NULL;
3037 char *match2 = NULL;
3038 char *match3 = NULL;
3039 char *match4 = NULL;
3040 DBusConnection *conn;
3041 DBusHandleMessageFunction event_func = NULL;
3043 retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
3045 conn = dbus_g_connection_get_connection(g_conn);
3046 retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
3048 switch (event_type) {
3049 case BT_MANAGER_EVENT:
3050 event_func = __bt_manager_event_filter;
3051 match1 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
3052 BT_MANAGER_INTERFACE,
3053 BT_INTERFACES_ADDED);
3055 match2 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
3056 BT_MANAGER_INTERFACE,
3057 BT_INTERFACES_REMOVED);
3059 match3 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
3060 BT_FREEDESKTOP_INTERFACE,
3061 BT_NAME_OWNER_CHANGED);
3063 match4 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
3064 BT_PROPERTIES_INTERFACE,
3065 BT_PROPERTIES_CHANGED);
3067 case BT_DEVICE_EVENT:
3068 match1 = g_strdup_printf(EVENT_MATCH_RULE,
3069 BT_DEVICE_INTERFACE);
3072 match1 = g_strdup_printf(EVENT_MATCH_RULE,
3073 BT_INPUT_INTERFACE);
3075 case BT_NETWORK_EVENT:
3076 match1 = g_strdup_printf(EVENT_MATCH_RULE,
3077 BT_NETWORK_SERVER_INTERFACE);
3079 match2 = g_strdup_printf(EVENT_MATCH_RULE,
3080 BT_NETWORK_CLIENT_INTERFACE);
3082 case BT_HEADSET_EVENT:
3083 match1 = g_strdup_printf(EVENT_MATCH_RULE,
3084 BT_HEADSET_INTERFACE);
3086 match2 = g_strdup_printf(EVENT_MATCH_RULE,
3089 case BT_OPP_SERVER_EVENT:
3090 BT_ERR("BT_OPP_SERVER_EVENT: register service event");
3091 event_func = __bt_obexd_event_filter;
3092 match1 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
3093 BT_PROPERTIES_INTERFACE,
3094 BT_PROPERTIES_CHANGED);
3096 match2 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
3097 BT_MANAGER_INTERFACE,
3098 BT_INTERFACES_ADDED);
3100 match3 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
3101 BT_MANAGER_INTERFACE,
3102 BT_INTERFACES_REMOVED);
3104 case BT_OPP_CLIENT_EVENT:
3105 BT_ERR("BT_OPP_CLIENT_EVENT: register service event");
3106 event_func = __bt_opc_event_filter;
3107 match1 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
3108 BT_PROPERTIES_INTERFACE,
3109 BT_PROPERTIES_CHANGED);
3111 match2 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
3112 BT_MANAGER_INTERFACE,
3113 BT_INTERFACES_ADDED);
3115 match3 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
3116 BT_MANAGER_INTERFACE,
3117 BT_INTERFACES_REMOVED);
3120 BT_ERR("Unknown event");
3121 return BLUETOOTH_ERROR_INTERNAL;
3125 if (!dbus_connection_add_filter(conn, event_func,
3127 BT_ERR("Fail to add filter");
3132 dbus_error_init(&dbus_error);
3135 dbus_bus_add_match(conn, match1, &dbus_error);
3137 if (dbus_error_is_set(&dbus_error)) {
3138 BT_ERR("Fail to add match: %s\n", dbus_error.message);
3139 dbus_error_free(&dbus_error);
3144 dbus_bus_add_match(conn, match2, &dbus_error);
3146 if (dbus_error_is_set(&dbus_error)) {
3147 BT_ERR("Fail to add match: %s\n", dbus_error.message);
3148 dbus_error_free(&dbus_error);
3153 dbus_bus_add_match(conn, match3, &dbus_error);
3155 if (dbus_error_is_set(&dbus_error)) {
3156 BT_ERR("Fail to add match: %s\n", dbus_error.message);
3157 dbus_error_free(&dbus_error);
3162 dbus_bus_add_match(conn, match4, &dbus_error);
3164 if (dbus_error_is_set(&dbus_error)) {
3165 BT_ERR("Fail to add match: %s\n", dbus_error.message);
3166 dbus_error_free(&dbus_error);
3176 return BLUETOOTH_ERROR_NONE;
3186 return BLUETOOTH_ERROR_INTERNAL;
3189 void _bt_unregister_service_event(DBusGConnection *g_conn, int event_type)
3193 DBusConnection *conn;
3194 DBusHandleMessageFunction event_func;
3196 ret_if(g_conn == NULL);
3197 conn = dbus_g_connection_get_connection(g_conn);
3199 switch (event_type) {
3200 case BT_MANAGER_EVENT:
3201 event_func = __bt_manager_event_filter;
3203 case BT_OPP_SERVER_EVENT:
3204 event_func = __bt_obexd_event_filter;
3206 case BT_OPP_CLIENT_EVENT:
3207 event_func = __bt_opc_event_filter;
3210 BT_ERR("Unknown event");
3214 ret_if(conn == NULL);
3216 dbus_connection_remove_filter(conn, event_func, NULL);
3220 static int __bt_init_manager_receiver(void)
3224 GError *error = NULL;
3226 if (manager_conn == NULL) {
3227 manager_conn = dbus_g_bus_get(DBUS_BUS_SYSTEM, &error);
3228 if (error != NULL) {
3229 BT_ERR("ERROR: Can't get on system bus [%s]", error->message);
3230 g_error_free(error);
3232 retv_if(manager_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
3235 if (_bt_register_service_event(manager_conn,
3236 BT_MANAGER_EVENT) != BLUETOOTH_ERROR_NONE)
3239 if (_bt_register_service_event(manager_conn,
3240 BT_DEVICE_EVENT) != BLUETOOTH_ERROR_NONE)
3243 if (_bt_register_service_event(manager_conn,
3244 BT_HID_EVENT) != BLUETOOTH_ERROR_NONE)
3247 if (_bt_register_service_event(manager_conn,
3248 BT_HEADSET_EVENT) != BLUETOOTH_ERROR_NONE)
3251 if (_bt_register_service_event(manager_conn,
3252 BT_NETWORK_EVENT) != BLUETOOTH_ERROR_NONE)
3255 return BLUETOOTH_ERROR_NONE;
3258 dbus_g_connection_unref(manager_conn);
3259 manager_conn = NULL;
3264 return BLUETOOTH_ERROR_INTERNAL;
3267 static int __bt_init_obexd_receiver(void)
3270 GError *error = NULL;
3272 if (obexd_conn == NULL) {
3273 obexd_conn = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
3274 if (error != NULL) {
3275 BT_ERR("ERROR: Can't get on session bus [%s]", error->message);
3276 g_error_free(error);
3278 retv_if(obexd_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
3281 if (_bt_register_service_event(obexd_conn,
3282 BT_OPP_SERVER_EVENT) != BLUETOOTH_ERROR_NONE) {
3283 dbus_g_connection_unref(obexd_conn);
3285 return BLUETOOTH_ERROR_INTERNAL;
3290 return BLUETOOTH_ERROR_NONE;
3293 /* To receive the event from bluez */
3294 int _bt_init_service_event_receiver(void)
3300 result = __bt_init_manager_receiver();
3301 retv_if(result != BLUETOOTH_ERROR_NONE, result);
3303 result = __bt_init_obexd_receiver();
3304 if (result != BLUETOOTH_ERROR_NONE)
3305 BT_ERR("Fail to init obexd receiver");
3309 return BLUETOOTH_ERROR_NONE;
3312 void _bt_deinit_service_event_receiver(void)
3316 _bt_unregister_service_event(manager_conn, BT_MANAGER_EVENT);
3318 _bt_unregister_service_event(obexd_conn, BT_OPP_SERVER_EVENT);
3321 dbus_g_connection_unref(manager_conn);
3322 manager_conn = NULL;
3326 dbus_g_connection_unref(obexd_conn);
3331 g_source_remove(event_id);