Generate BT disable HAL event when bluez is terminated
[platform/core/connectivity/bluetooth-frwk.git] / bt-service-adaptation / services / adapter / bt-service-core-adapter.c
1 /*
2  * Copyright (c) 2015 2016 Samsung Electronics Co., Ltd All Rights Reserved
3  *
4  * Contact: Anupam Roy <anupam.r@samsung.com>
5  *
6  * Licensed under the Apache License, Version 2.0 (the "License");
7  * you may not use this file except in compliance with the License.
8  * You may obtain a copy of the License at
9  *
10  *              http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and
16  * limitations under the License.
17  *
18  */
19
20 #include <stdio.h>
21 #include <gio/gio.h>
22 #include <glib.h>
23 #include <dlog.h>
24 #include <string.h>
25 #include <vconf.h>
26 #include <vconf-internal-keys.h>
27 #include <bundle.h>
28 #include <bundle_internal.h>
29 #include <eventsystem.h>
30
31 #include "alarm.h"
32
33 /*bt-service headers */
34 #include "bt-internal-types.h"
35 #include "bt-service-common.h"
36 #include "bt-service-util.h"
37 #include "bt-service-main.h"
38 #include "bt-service-core-adapter.h"
39 #include "bt-service-core-device.h"
40 #include "bt-service-event-receiver.h"
41 #include "bt-request-handler.h"
42 #include "bt-service-event.h"
43 #include "bt-service-audio-common.h"
44 #include "bt-service-core-adapter-le.h"
45 #include "bt-service-gatt.h"
46
47 #ifdef TIZEN_FEATURE_BT_DPM
48 #include "bt-service-dpm.h"
49 #endif
50 #include "bt-service-hidhost.h"
51 #include "bt-service-hiddevice.h"
52 #include "bt-service-socket.h"
53 #include "bt-service-hdp.h"
54
55 /* OAL headers */
56 #include <oal-event.h>
57 #include <oal-manager.h>
58 #include <oal-adapter-mgr.h>
59
60 #ifdef TIZEN_FEATURE_BT_PAN_NAP
61 #include "bt-service-network.h"
62 #endif
63 /*This file will contain state machines related to adapter and remote device */
64
65 #include "bt-internal-types.h"
66
67 /* Global variables */
68 typedef struct {
69         guint event_id;
70         int timeout;
71         time_t start_time;
72         gboolean alarm_init;
73         int alarm_id;
74 } bt_adapter_timer_t;
75
76 static bt_adapter_timer_t visible_timer;
77
78 static guint timer_id = 0;
79
80 static gboolean a2dp_init_pending = TRUE;
81
82 /* Adapter default states */
83 static bt_status_t adapter_state = BT_DEACTIVATED;
84 static bt_adapter_discovery_state_t adapter_discovery_state = ADAPTER_DISCOVERY_STOPPED;
85
86 /* Forward declarations */
87 static void __bt_adapter_event_handler(int event_type, gpointer event_data);
88 static void __bt_post_oal_init(void);
89 static void __bt_handle_oal_initialisation(oal_event_t event);
90 static void __bt_adapter_handle_pending_requests(int service_function, void *user_data, unsigned int size);
91 static gboolean __bt_adapter_post_set_enabled(gpointer user_data);
92 static gboolean __bt_adapter_post_set_disabled(gpointer user_data);
93 static void __bt_adapter_update_bt_enabled(void);
94 static void __bt_adapter_update_bt_disabled(void);
95 static void __bt_adapter_state_set_status(bt_status_t status);
96 static void __bt_adapter_update_discovery_status(bt_adapter_discovery_state_t status);
97 static void __bt_adapter_state_change_callback(int bt_status);
98 static int __bt_adapter_state_handle_request(gboolean enable);
99 static int __bt_adapter_state_discovery_request(gboolean enable,
100                 unsigned short max_response, unsigned short duration, unsigned int mask,
101                 gboolean is_custom, bt_discovery_role_type_t role);
102 static void __bt_adapter_discovery_state_change_callback(int bt_discovery_status);
103 static gboolean __bt_is_service_request_present(int service_function);
104
105 static void __bt_set_visible_mode(void);
106 static void __bt_set_local_name(void);
107
108 /* Initialize BT stack (Initialize OAL layer) */
109 int _bt_stack_init(void)
110 {
111         int ret;
112
113         BT_INFO("[bt-service] Start to initialize BT stack");
114         /* Adapter enable request is successful, setup event handlers */
115         _bt_service_register_event_handler_callback(
116                         BT_ADAPTER_MODULE, __bt_adapter_event_handler);
117
118         ret = _bt_le_init();
119         if (ret != BLUETOOTH_ERROR_NONE) {
120                 BT_ERR("_bt_le_init Failed");
121                 return ret;
122         }
123
124         ret = oal_bt_init(_bt_service_oal_event_receiver);
125
126         if (OAL_STATUS_PENDING == ret) {
127                 BT_INFO("OAL Initialisation Pending, Profiles Init will be done once oal initialised...");
128                 return BLUETOOTH_ERROR_NONE;
129         } else if (OAL_STATUS_SUCCESS != ret) {
130                 _bt_service_unregister_event_handler_callback(BT_ADAPTER_MODULE);
131                 return BLUETOOTH_ERROR_INTERNAL;
132         }
133
134         return BLUETOOTH_ERROR_NONE;
135 }
136
137 int _bt_enable_adapter(void)
138 {
139         return __bt_adapter_state_handle_request(TRUE);
140 }
141
142 int _bt_enable_core(void)
143 {
144         /* TODO_40 : 4.0 merge  */
145         BT_INFO("Not Supported");
146         return BLUETOOTH_ERROR_NOT_SUPPORT;
147 }
148
149 int _bt_recover_adapter(void)
150 {
151         /* TODO_40 : 4.0 merge  */
152         BT_INFO("Not Supported");
153         return BLUETOOTH_ERROR_NOT_SUPPORT;
154 }
155
156 int _bt_reset_adapter(void)
157 {
158         BT_INFO("+");
159         if (OAL_STATUS_SUCCESS != adapter_reset())
160                 return BLUETOOTH_ERROR_INTERNAL;
161
162         /* TODO_40 : 4.0 merge  */
163         /* TODO Currently bt-service is not terminated in tizen next.
164            It should be handled in future patch */
165         if (_bt_adapter_get_status() == BT_DEACTIVATED)
166                 g_idle_add((GSourceFunc)_bt_terminate_service, NULL);
167
168         return BLUETOOTH_ERROR_NONE;
169 }
170
171 int _bt_check_adapter(int *status)
172 {
173         BT_INFO("+");
174         gboolean powered = FALSE;
175         BT_CHECK_PARAMETER(status, return);
176
177         *status = BT_ADAPTER_DISABLED;
178
179         if (OAL_STATUS_SUCCESS != adapter_get_powered_status(&powered))
180                 return BLUETOOTH_ERROR_INTERNAL;
181         else if (powered) {
182                 BT_INFO("Adapter is in Powered Up state");
183                 *status = BT_ADAPTER_ENABLED;
184         } else
185                 BT_INFO("Adapter is in Powered Down state");
186
187         return BLUETOOTH_ERROR_NONE;
188 }
189
190 int _bt_disable_adapter(void)
191 {
192         return __bt_adapter_state_handle_request(FALSE);
193 }
194
195 int _bt_start_discovery(unsigned short max_response,
196                 unsigned short duration, unsigned int cod_mask)
197 {
198         return __bt_adapter_state_discovery_request(TRUE, max_response, duration,
199                                 cod_mask, FALSE, 0x00);
200 }
201
202 int _bt_start_custom_discovery(bt_discovery_role_type_t role)
203 {
204         return __bt_adapter_state_discovery_request(TRUE, 0, 0, 0, TRUE, role);
205 }
206
207 int _bt_cancel_discovery(void)
208 {
209         return __bt_adapter_state_discovery_request(FALSE, 0, 0, 0, FALSE, 0x00);
210 }
211
212 gboolean _bt_is_discovering(void)
213 {
214         if (adapter_discovery_state == ADAPTER_DISCOVERY_STARTED
215                         || adapter_discovery_state == ADAPTER_DISCOVERY_STARTING)
216                 return TRUE;
217         else
218                 return FALSE;
219 }
220
221 int _bt_get_local_address(void)
222 {
223         int result;
224
225         BT_DBG("+");
226
227         result =  adapter_get_address();
228         if (result != OAL_STATUS_SUCCESS) {
229                 BT_ERR("adapter_get_address failed: %d", result);
230                 result = BLUETOOTH_ERROR_INTERNAL;
231         } else
232                 result = BLUETOOTH_ERROR_NONE;
233
234         BT_DBG("-");
235         return result;
236 }
237
238 int _bt_get_local_version(void)
239 {
240         int result;
241         BT_DBG("+");
242
243         result =  adapter_get_version();
244         if (result != OAL_STATUS_SUCCESS) {
245                 BT_ERR("adapter_get_version failed: %d", result);
246                 result = BLUETOOTH_ERROR_INTERNAL;
247         } else
248                 result = BLUETOOTH_ERROR_NONE;
249
250         BT_DBG("-");
251         return result;
252 }
253
254 int _bt_get_local_name(void)
255 {
256         int result;
257
258         BT_DBG("+");
259
260         result =  adapter_get_name();
261         if (result != OAL_STATUS_SUCCESS) {
262                 BT_ERR("adapter_get_name failed: %d", result);
263                 result = BLUETOOTH_ERROR_INTERNAL;
264         } else
265                 result = BLUETOOTH_ERROR_NONE;
266
267         BT_DBG("-");
268         return result;
269 }
270
271 int _bt_set_local_name(char *local_name)
272 {
273         int result = BLUETOOTH_ERROR_NONE;
274         BT_DBG("+");
275
276         retv_if(NULL == local_name, BLUETOOTH_ERROR_INVALID_PARAM);
277
278         result =  adapter_set_name(local_name);
279         if (result != OAL_STATUS_SUCCESS) {
280                 BT_ERR("adapter_set_name failed: %d", result);
281                 result = BLUETOOTH_ERROR_INTERNAL;
282         } else
283                 result = BLUETOOTH_ERROR_NONE;
284
285         BT_DBG("-");
286         return result;
287 }
288
289 int _bt_get_discoverable_mode(int *mode)
290 {
291         int scan_mode = 0;
292         int timeout = 0;
293
294         BT_DBG("+");
295
296         retv_if(NULL == mode, BLUETOOTH_ERROR_INVALID_PARAM);
297
298         adapter_is_discoverable(&scan_mode);
299         if (TRUE == scan_mode) {
300                 adapter_get_discoverable_timeout(&timeout);
301                 if (timeout > 0)
302                         *mode = BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE;
303                 else
304                         *mode = BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE;
305         } else {
306                 adapter_is_connectable(&scan_mode);
307                 if (scan_mode == TRUE)
308                         *mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
309                 else {
310                         /*
311                          * TODO: NON CONNECTABLE is not defined in bluetooth_discoverable_mode_t.
312                          * After adding BLUETOOTH_DISCOVERABLE_MODE_NON_CONNECTABLE, set mode as
313                          * BLUETOOTH_DISCOVERABLE_MODE_NON_CONNECTABLE. Until then set -1.
314                          */
315                         *mode = -1;
316                 }
317         }
318
319         BT_DBG("-");
320         return BLUETOOTH_ERROR_NONE;
321 }
322
323 int _bt_get_timeout_value(int *timeout)
324 {
325         time_t current_time;
326         int time_diff;
327
328         /* Take current time */
329         time(&current_time);
330         time_diff = difftime(current_time, visible_timer.start_time);
331
332         BT_DBG("Time diff = %d\n", time_diff);
333         *timeout = visible_timer.timeout - time_diff;
334
335         return BLUETOOTH_ERROR_NONE;
336 }
337
338 static void __bt_visibility_alarm_remove()
339 {
340         if (visible_timer.event_id > 0) {
341                 g_source_remove(visible_timer.event_id);
342                 visible_timer.event_id = 0;
343         }
344
345         if (visible_timer.alarm_id > 0) {
346                 alarmmgr_remove_alarm(visible_timer.alarm_id);
347                 visible_timer.alarm_id = 0;
348         }
349 }
350
351 static int __bt_visibility_alarm_cb(alarm_id_t alarm_id, void* user_param)
352 {
353         int result = BLUETOOTH_ERROR_NONE;
354         int timeout = 0;
355
356         BT_DBG("__bt_visibility_alarm_cb - alram id = [%d] \n", alarm_id);
357
358         if (alarm_id != visible_timer.alarm_id)
359                 return 0;
360
361         if (visible_timer.event_id) {
362                 _bt_send_event(BT_ADAPTER_EVENT,
363                                 BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED,
364                                 g_variant_new("(in)", result, timeout));
365                 g_source_remove(visible_timer.event_id);
366                 visible_timer.event_id = 0;
367                 visible_timer.timeout = 0;
368
369                 if (!TIZEN_PROFILE_WEARABLE) {
370                         if (vconf_set_int(BT_FILE_VISIBLE_TIME, 0) != 0)
371                                 BT_ERR("Set vconf failed\n");
372                 }
373         }
374         /* Switch Off visibility in Bluez */
375         _bt_set_discoverable_mode(BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE, 0);
376         visible_timer.alarm_id = 0;
377         return 0;
378 }
379
380 static gboolean __bt_timeout_handler(gpointer user_data)
381 {
382         int result = BLUETOOTH_ERROR_NONE;
383         time_t current_time;
384         int time_diff;
385
386         /* Take current time */
387         time(&current_time);
388         time_diff = difftime(current_time, visible_timer.start_time);
389
390         /* Send event to application */
391         _bt_send_event(BT_ADAPTER_EVENT,
392                         BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED,
393                         g_variant_new("(in)", result, time_diff));
394
395         if (visible_timer.timeout <= time_diff) {
396                 g_source_remove(visible_timer.event_id);
397                 visible_timer.event_id = 0;
398                 visible_timer.timeout = 0;
399
400                 if (!TIZEN_PROFILE_WEARABLE) {
401                         if (vconf_set_int(BT_FILE_VISIBLE_TIME, 0) != 0)
402                                 BT_ERR("Set vconf failed\n");
403                 }
404
405                 return FALSE;
406         }
407
408         return TRUE;
409 }
410
411 static void __bt_visibility_alarm_create()
412 {
413         alarm_id_t alarm_id;
414         int result;
415
416         result = alarmmgr_add_alarm(ALARM_TYPE_VOLATILE, visible_timer.timeout,
417                         0, NULL, &alarm_id);
418         if (result < 0) {
419                 BT_ERR("Failed to create alarm error = %d\n", result);
420         } else {
421                 BT_DBG("Alarm created = %d\n", alarm_id);
422                 visible_timer.alarm_id = alarm_id;
423         }
424 }
425
426 int _bt_start_visibility_timer(int timeout)
427 {
428         int result;
429 #ifdef TIZEN_FEATURE_BT_DPM
430         int discoverable_state = DPM_BT_ERROR;
431 #endif
432
433         __bt_visibility_alarm_remove();
434
435         visible_timer.timeout = timeout;
436
437 #ifdef TIZEN_FEATURE_BT_DPM
438         _bt_dpm_get_bluetooth_limited_discoverable_state(&discoverable_state);
439         if (discoverable_state != DPM_RESTRICTED) {
440 #endif
441                 if (vconf_set_int(BT_FILE_VISIBLE_TIME, timeout) != 0)
442                         BT_ERR("Set vconf failed");
443 #ifdef TIZEN_FEATURE_BT_DPM
444         }
445 #endif
446
447         if (timeout <= 0)
448                 return BLUETOOTH_ERROR_NONE;
449
450         if (!visible_timer.alarm_init) {
451                 /* Set Alarm timer to switch off BT */
452                 result = alarmmgr_init("bt-service");
453                 if (result != 0)
454                         return BLUETOOTH_ERROR_INTERNAL;
455
456                 visible_timer.alarm_init = TRUE;
457         }
458
459         result = alarmmgr_set_cb(__bt_visibility_alarm_cb, NULL);
460         if (result != 0)
461                 return BLUETOOTH_ERROR_INTERNAL;
462
463         if (!TIZEN_PROFILE_WEARABLE) {
464                 if (vconf_set_int(BT_FILE_VISIBLE_TIME, timeout) != 0)
465                         BT_ERR("Set vconf failed");
466         }
467
468         /* Take start time */
469         time(&(visible_timer.start_time));
470         visible_timer.event_id = g_timeout_add_seconds(1,
471                         __bt_timeout_handler, NULL);
472
473         visible_timer.timeout = timeout;
474
475         __bt_visibility_alarm_create();
476
477         return BLUETOOTH_ERROR_NONE;
478 }
479
480 int _bt_stop_visibility_timer(void)
481 {
482         __bt_visibility_alarm_remove();
483
484         visible_timer.timeout = 0;
485
486         if (!TIZEN_PROFILE_WEARABLE) {
487                 if (vconf_set_int(BT_FILE_VISIBLE_TIME, 0) != 0)
488                         BT_ERR("Set vconf failed");
489         }
490
491         return BLUETOOTH_ERROR_NONE;
492 }
493
494 int _bt_set_discoverable_mode(int discoverable_mode, int timeout)
495 {
496         int result;
497         int ret = BLUETOOTH_ERROR_NONE;;
498 #ifdef TIZEN_FEATURE_BT_DPM
499         int discoverable_state = DPM_BT_ERROR;
500 #endif
501
502         BT_DBG("+");
503
504         BT_INFO("discoverable_mode: %d, timeout: %d", discoverable_mode, timeout);
505
506 #ifdef TIZEN_FEATURE_BT_DPM
507         _bt_dpm_get_bluetooth_limited_discoverable_state(&discoverable_state);
508         if (discoverable_mode != BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE &&
509                  discoverable_state == DPM_RESTRICTED) {
510                 if (headed_plugin_info->plugin_headed_enabled)
511                         headed_plugin_info->headed_plugin->bt_launch_dpmpopup("DPM_POLICY_DISABLE_BT_HANDSFREE");
512                 return BLUETOOTH_ERROR_ACCESS_DENIED;
513         }
514         if (discoverable_mode == BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE &&
515                 discoverable_state == DPM_RESTRICTED) {
516                 if (headed_plugin_info->plugin_headed_enabled)
517                         headed_plugin_info->headed_plugin->bt_launch_dpmpopup("DPM_POLICY_DISABLE_BT");
518                 return BLUETOOTH_ERROR_ACCESS_DENIED;
519         }
520 #endif
521
522         switch (discoverable_mode) {
523         case BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE:
524                 result = adapter_set_connectable(TRUE);
525                 timeout = 0;
526                 break;
527         case BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE:
528                 result = adapter_set_discoverable();
529                 timeout = 0;
530                 break;
531         case BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE:
532                 result = adapter_set_discoverable();
533                 break;
534         default:
535                 return BLUETOOTH_ERROR_INVALID_PARAM;
536         }
537
538         if (result != OAL_STATUS_SUCCESS) {
539                 BT_ERR("set scan mode failed %d", result);
540                 return BLUETOOTH_ERROR_INTERNAL;
541         }
542
543         result = adapter_set_discoverable_timeout(timeout);
544         if (result != OAL_STATUS_SUCCESS) {
545                 BT_ERR("adapter_set_discoverable_timeout failed %d", result);
546                 return BLUETOOTH_ERROR_INTERNAL;
547         }
548
549         if (discoverable_mode == BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE) {
550                 ret = _bt_stop_visibility_timer();
551                 if (BLUETOOTH_ERROR_NONE != ret)
552                         BT_ERR("_bt_stop_visibility_timer failed");
553                 if (!TIZEN_PROFILE_WEARABLE) {
554                         if (vconf_set_int(BT_FILE_VISIBLE_TIME, -1) != 0)
555                                  BT_ERR("Set vconf failed");
556                 }
557         } else if (discoverable_mode == BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE) {
558                 ret = _bt_start_visibility_timer(timeout);
559                 if (BLUETOOTH_ERROR_NONE != ret)
560                         BT_ERR("_bt_start_visibility_timer failed");
561
562         } else {
563                 ret = _bt_stop_visibility_timer();
564                 if (BLUETOOTH_ERROR_NONE != ret)
565                         BT_ERR("_bt_stop_visibility_timer failed");
566         }
567
568         BT_DBG("-");
569         return result;
570 }
571
572 gboolean _bt_is_connectable(void)
573 {
574         int connectable = 0;
575         int result;
576
577         BT_DBG("+");
578
579         adapter_is_connectable(&connectable);
580         if (connectable)
581                 result = TRUE;
582         else
583                 result = FALSE;
584
585         BT_DBG("Connectable: [%s]", result ? "TRUE" : "FALSE");
586         BT_DBG("-");
587         return result;
588 }
589
590 int _bt_set_connectable(gboolean connectable)
591 {
592         int result = BLUETOOTH_ERROR_NONE;
593
594         BT_DBG("+");
595         result =  adapter_set_connectable(connectable);
596         if (result != OAL_STATUS_SUCCESS) {
597                 BT_ERR("adapter_set_connectable failed: %d", result);
598                 result = BLUETOOTH_ERROR_INTERNAL;
599         } else
600                 result = BLUETOOTH_ERROR_NONE;
601
602         BT_DBG("-");
603         return result;
604 }
605
606 int _bt_is_service_used(void)
607 {
608         int result;
609
610         BT_DBG("+");
611
612         result =  adapter_get_service_uuids();
613         if (result != OAL_STATUS_SUCCESS) {
614                 BT_ERR("adapter_get_service_uuids failed: %d", result);
615                 result = BLUETOOTH_ERROR_INTERNAL;
616         } else {
617                 result = BLUETOOTH_ERROR_NONE;
618         }
619
620         BT_DBG("-");
621         return result;
622 }
623
624 int _bt_adapter_get_bonded_devices(void)
625 {
626         int result = BLUETOOTH_ERROR_NONE;
627
628         BT_DBG("+");
629         result =  adapter_get_bonded_devices();
630         if (result != OAL_STATUS_SUCCESS) {
631                 BT_ERR("adapter_get_bonded_devices failed: %d", result);
632                 result = BLUETOOTH_ERROR_INTERNAL;
633         } else
634                 result = BLUETOOTH_ERROR_NONE;
635
636         BT_DBG("-");
637         return result;
638 }
639
640 int _bt_get_profile_connected_devices(char *profile_uuid, GArray **addr_list)
641 {
642         BT_DBG("+");
643         GDBusConnection *conn;
644         GDBusProxy *manager_proxy;
645         GVariant *result = NULL;
646         GVariant *result1 = NULL;
647         GVariantIter *iter = NULL;
648         GError *error = NULL;
649         char *object_path = NULL;
650         GVariantIter *interface_iter;
651         char *interface_str = NULL;
652         GDBusProxy *device_proxy = NULL;
653         gboolean is_connected = FALSE;
654
655         conn = _bt_gdbus_get_system_gconn();
656         retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
657
658         manager_proxy = _bt_get_manager_proxy();
659         retv_if(manager_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
660
661         result = g_dbus_proxy_call_sync(manager_proxy, "GetManagedObjects",
662                         NULL,
663                         G_DBUS_CALL_FLAGS_NONE,
664                         -1,
665                         NULL,
666                         NULL);
667
668         if (!result) {
669                 if (error != NULL) {
670                         BT_ERR("Failed to GetManagedObjects (Error: %s)", error->message);
671                         g_clear_error(&error);
672                         error = NULL;
673                 } else
674                         BT_ERR("Failed to Failed to GetManagedObjects");
675                 return BLUETOOTH_ERROR_INTERNAL;
676         }
677
678         /* signature of GetManagedObjects:  a{oa{sa{sv}}} */
679         g_variant_get(result, "(a{oa{sa{sv}}})", &iter);
680
681         /* Parse the signature:  oa{sa{sv}}} */
682         while (g_variant_iter_loop(iter, "{&oa{sa{sv}}}", &object_path, &interface_iter)) {
683                 if (object_path == NULL)
684                         continue;
685
686                 while (g_variant_iter_loop(interface_iter, "{sa{sv}}",
687                                         &interface_str, NULL)) {
688                         if (g_strcmp0(interface_str, "org.bluez.Device1") == 0) {
689                                 BT_DBG("Found a device: %s", object_path);
690                                 g_free(interface_str);
691
692                                 device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
693                                                 NULL, BT_BLUEZ_NAME,
694                                                 object_path, BT_DEVICE_INTERFACE,  NULL, NULL);
695
696                                 if (device_proxy == NULL) {
697                                         BT_DBG("Device don't have this service");
698                                         break;
699                                 }
700
701                                 result1 = g_dbus_proxy_call_sync(device_proxy, "IsConnectedProfile",
702                                                 g_variant_new("(s)", profile_uuid),
703                                                 G_DBUS_CALL_FLAGS_NONE,
704                                                 -1,
705                                                 NULL,
706                                                 &error);
707
708                                 if (result1 == NULL) {
709                                         BT_ERR("Error occured in Proxy call");
710                                         if (error) {
711                                                 BT_ERR("Error occured in Proxy call [%s]\n", error->message);
712                                                 g_error_free(error);
713                                                 error = NULL;
714                                         }
715                                         g_object_unref(device_proxy);
716                                         break;
717                                 }
718                                 g_variant_get(result1, "(b)", &is_connected);
719
720                                 if (is_connected == TRUE) {
721                                         char address[BT_ADDRESS_STRING_SIZE];
722                                         bluetooth_device_address_t *addr = NULL;
723
724                                         _bt_convert_device_path_to_address(object_path, address);
725
726                                         addr = g_malloc0(sizeof(bluetooth_device_address_t));
727                                         _bt_convert_addr_string_to_type(addr->addr, address);
728
729                                         g_array_append_vals(*addr_list, addr,
730                                                         sizeof(bluetooth_device_address_t));
731                                 }
732
733                                 g_variant_unref(result1);
734                                 g_object_unref(device_proxy);
735
736                                 break;
737                         }
738                 }
739         }
740
741         g_variant_unref(result);
742         g_variant_iter_free(iter);
743
744         BT_DBG("-");
745         return BLUETOOTH_ERROR_NONE;
746 }
747
748 static void __bt_handle_pending_a2dp_init(unsigned int a2dp_role)
749 {
750         int ret;
751
752         if (!a2dp_init_pending)
753                 return;
754
755         BT_DBG("+");
756         a2dp_init_pending = FALSE;
757
758         if (a2dp_role == BT_A2DP_SINK_ROLE) {
759                 BT_INFO("Enable A2DP Sink role");
760                 /* Initialize A2DP Sink */
761                 ret = _bt_audio_initialize(BT_A2DP_SINK_MODULE);
762                 if (ret != BLUETOOTH_ERROR_NONE)
763                         BT_ERR("_bt_audio_initialize(BT_A2DP_SINK_MODULE) Failed");
764
765                 /* Initialize AVRCP Controller */
766                 ret = _bt_audio_initialize(BT_AVRCP_CTRL_MODULE);
767                 if (ret != BLUETOOTH_ERROR_NONE)
768                         BT_ERR("_bt_audio_initialize(BT_AVRCP_CTRL_MODULE) Failed");
769
770                 _bt_audio_set_current_role(BLUETOOTH_A2DP_SINK);
771                 return;
772         }
773
774         BT_INFO("Enable A2DP Source role");
775         /* Initialize A2DP Source */
776         ret = _bt_audio_initialize(BT_A2DP_SOURCE_MODULE);
777         if (ret != BLUETOOTH_ERROR_NONE)
778                 BT_ERR("_bt_audio_initialize(BT_A2DP_SOURCE_MODULE) Failed");
779
780         /* Initialize AVRCP Target */
781         ret = _bt_audio_initialize(BT_AVRCP_MODULE);
782         if (ret != BLUETOOTH_ERROR_NONE)
783                 BT_ERR("_bt_audio_initialize(BT_AVRCP_MODULE) Failed");
784
785         _bt_audio_set_current_role(BLUETOOTH_A2DP_SOURCE);
786         BT_DBG("-");
787 }
788
789 static void __bt_adapter_event_handler(int event_type, gpointer event_data)
790 {
791         int result = BLUETOOTH_ERROR_NONE;
792
793         BT_DBG("+");
794
795         switch (event_type) {
796         case OAL_EVENT_OAL_INITIALISED_SUCCESS:
797         case OAL_EVENT_OAL_INITIALISED_FAILED:
798                 __bt_handle_oal_initialisation(event_type);
799                 break;
800         case OAL_EVENT_ADAPTER_ENABLED:
801                 __bt_adapter_state_change_callback(BT_ACTIVATED);
802                 break;
803         case OAL_EVENT_ADAPTER_DISABLED:
804                 __bt_adapter_state_change_callback(BT_DEACTIVATED);
805                 break;
806         case OAL_EVENT_ADAPTER_INQUIRY_STARTED:
807                 __bt_adapter_discovery_state_change_callback(ADAPTER_DISCOVERY_STARTED);
808                 break;
809         case OAL_EVENT_ADAPTER_INQUIRY_FINISHED:
810                 __bt_adapter_discovery_state_change_callback(ADAPTER_DISCOVERY_STOPPED);
811                 break;
812         case OAL_EVENT_ADAPTER_PROPERTY_ADDRESS: {
813                 bt_address_t *bd_addr = event_data;
814                 bluetooth_device_address_t local_address;
815
816                 /* Copy data */
817                 memcpy(local_address.addr, bd_addr->addr, BT_ADDRESS_LENGTH_MAX);
818                 BT_DBG("Adapter address: [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]",
819                                 local_address.addr[0], local_address.addr[1], local_address.addr[2],
820                                 local_address.addr[3], local_address.addr[4], local_address.addr[5]);
821
822                 __bt_adapter_handle_pending_requests(BT_GET_LOCAL_ADDRESS,
823                                 (void *) &local_address, sizeof(bluetooth_device_address_t));
824                 break;
825         }
826         case OAL_EVENT_ADAPTER_PROPERTY_NAME: {
827                 char *name = event_data;
828                 BT_DBG("Adapter Name: %s", name);
829
830                 if (__bt_is_service_request_present(BT_GET_LOCAL_NAME)) {
831                         bluetooth_device_name_t local_name;
832
833                         memset(&local_name, 0x00, sizeof(bluetooth_device_name_t));
834                         g_strlcpy(local_name.name,
835                                 (const gchar *)name, BLUETOOTH_DEVICE_NAME_LENGTH_MAX);
836                         __bt_adapter_handle_pending_requests(BT_GET_LOCAL_NAME,
837                                 (void *) &local_name, sizeof(bluetooth_device_name_t));
838                 } else {
839                         /* Send event to application */
840                         _bt_send_event(BT_ADAPTER_EVENT,
841                                         BLUETOOTH_EVENT_LOCAL_NAME_CHANGED,
842                                         g_variant_new("(is)", result, name));
843                 }
844                 break;
845         }
846         case OAL_EVENT_ADAPTER_PROPERTY_VERSION: {
847                 char *ver = event_data;
848                 bluetooth_version_t local_version;
849
850                 memset(&local_version, 0x00, sizeof(bluetooth_version_t));
851                 g_strlcpy(local_version.version,
852                                 (const gchar *)ver, BLUETOOTH_VERSION_LENGTH_MAX);
853                 BT_DBG("BT Version: %s", local_version.version);
854
855                 __bt_adapter_handle_pending_requests(BT_GET_LOCAL_VERSION,
856                                 (void *) &local_version, sizeof(bluetooth_version_t));
857                 break;
858         }
859         case OAL_EVENT_ADAPTER_MODE_NON_CONNECTABLE: {
860                 int mode = -1;
861                 gboolean connectable = FALSE;
862
863                 BT_INFO("Adapter discoverable mode:"
864                                 " BLUETOOTH_DISCOVERABLE_MODE_NON_CONNECTABLE");
865                 _bt_send_event(BT_ADAPTER_EVENT,
866                                 BLUETOOTH_EVENT_CONNECTABLE_CHANGED,
867                                 g_variant_new("(b)", connectable));
868
869                 _bt_send_event(BT_ADAPTER_EVENT,
870                                 BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
871                                 g_variant_new("(in)", result, mode));
872                 break;
873         }
874         case OAL_EVENT_ADAPTER_MODE_CONNECTABLE: {
875                 int mode;
876                 gboolean connectable = TRUE;
877
878                 BT_INFO("Adapter discoverable mode:"
879                                 " BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE");
880                 _bt_send_event(BT_ADAPTER_EVENT,
881                                 BLUETOOTH_EVENT_CONNECTABLE_CHANGED,
882                                 g_variant_new("(b)", connectable));
883
884                 mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
885                 _bt_send_event(BT_ADAPTER_EVENT,
886                                 BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
887                                 g_variant_new("(in)", result, mode));
888                 break;
889         }
890         case OAL_EVENT_ADAPTER_MODE_DISCOVERABLE: {
891                 int mode;
892
893                 BT_INFO("Adapter discoverable mode:"
894                                 " BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE");
895
896                 /* Send event to application */
897                 mode = BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE;
898                 _bt_send_event(BT_ADAPTER_EVENT,
899                                 BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
900                                 g_variant_new("(in)", result, mode));
901
902                 break;
903         }
904         case OAL_EVENT_ADAPTER_MODE_DISCOVERABLE_TIMEOUT: {
905                 int *timeout = event_data;
906                 int mode;
907
908                 BT_INFO("Discoverable timeout: [%d]", *timeout);
909
910                 /* Send event to application */
911                 _bt_get_discoverable_mode(&mode);
912                 _bt_send_event(BT_ADAPTER_EVENT,
913                                 BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
914                                 g_variant_new("(in)", result, mode));
915                 break;
916         }
917         case OAL_EVENT_ADAPTER_PROPERTY_SERVICES: {
918                 int count;
919                 service_uuid_t *service_list;
920                 event_adapter_services_t *list = event_data;
921
922                 count = list->num;
923                 service_list = list->service_list;
924                 __bt_adapter_handle_pending_requests(BT_IS_SERVICE_USED, service_list, count);
925                 break;
926         }
927         case OAL_EVENT_ADAPTER_BONDED_DEVICE_LIST: {
928                 int i;
929                 int count;
930                 bluetooth_device_address_t *addr_list;
931
932                 event_device_list_t *bonded_device_list = event_data;
933                 count = bonded_device_list->num;
934
935                 addr_list = g_malloc0(count * sizeof(bluetooth_device_address_t));
936                 for (i = 0; i < count; i++) {
937                         memcpy(addr_list[i].addr,
938                                         bonded_device_list->devices[i].addr,
939                                         BLUETOOTH_ADDRESS_LENGTH);
940                 }
941
942                 BT_INFO("Adapter Bonded device List count: [%d]", count);
943                 _bt_device_handle_paired_address_list(addr_list, bonded_device_list->num);
944                 g_free(addr_list);
945                 break;
946         }
947         case OAL_EVENT_ADAPTER_PROPERTY_A2DP_ROLE: {
948                 unsigned int *a2dp_role = event_data;
949
950                 BT_INFO("a2dp role: [%u]", *a2dp_role);
951
952                 __bt_handle_pending_a2dp_init(*a2dp_role);
953
954                 break;
955         }
956         default:
957                 BT_ERR("Unhandled event..");
958                 break;
959         }
960
961         BT_DBG("-");
962 }
963
964 int _bt_init_profiles()
965 {
966         int ret;
967         BT_INFO("+");
968
969         /*TODO: Init bluetooth profiles */
970         ret = _bt_hidhost_initialize();
971         if (ret != BLUETOOTH_ERROR_NONE)
972                 BT_ERR("_bt_hidhost_initialize Failed");
973
974         ret = _bt_hiddevice_initialize();
975         if (ret != BLUETOOTH_ERROR_NONE)
976                 BT_ERR("_bt_hiddevice_initialize Failed");
977
978         ret = _bt_socket_init();
979         if (ret != BLUETOOTH_ERROR_NONE)
980                 BT_ERR("_bt_socket_init Failed");
981
982         /* Initialize HFP Audio Gateway */
983         ret = _bt_audio_initialize(BT_AG_MODULE);
984         if (ret != BLUETOOTH_ERROR_NONE)
985                 BT_ERR("_bt_audio_initialize(BT_AG_MODULE) Failed");
986
987         /* Registering callback for receiving audio services searched */
988         ret = _bt_audio_initialize(BT_AUDIO_ALL_MODULE);
989         if (ret != BLUETOOTH_ERROR_NONE)
990                 BT_ERR("_bt_audio_initialize(BT_AUDIO_ALL_MODULE) Failed");
991
992         ret = _bt_hdp_init();
993         if (ret != BLUETOOTH_ERROR_NONE)
994                 BT_ERR("_bt_hdp_init Failed");
995
996         ret = _bt_gatt_init();
997         if (ret != BLUETOOTH_ERROR_NONE)
998                 BT_ERR("_bt_gatt_init Failed");
999
1000         /* Initialize HF Client */
1001         ret = _bt_audio_initialize(BT_HFP_MODULE);
1002         if (ret != BLUETOOTH_ERROR_NONE)
1003                 BT_ERR("_bt_audio_initialize(BT_HFP_MODULE) Failed");
1004
1005         return BLUETOOTH_ERROR_NONE;
1006 }
1007
1008 int _bt_cleanup_profiles(void)
1009 {
1010         /* TODO: Cleanup bluetooth profiles */
1011         _bt_hidhost_deinitialize();
1012         _bt_socket_deinit();
1013 #if 0
1014         /* TODO: Cleanup bluetooth audio profiles */
1015         //_bt_audio_deinitialize(BT_A2DP_SOURCE_MODULE);
1016         //_bt_audio_deinitialize(BT_AVRCP_MODULE);
1017         //_bt_audio_deinitialize(BT_A2DP_SINK_MODULE);
1018         //_bt_audio_deinitialize(BT_AG_MODULE);
1019         //_bt_audio_deinitialize(BT_AVRCP_CTRL_MODULE);
1020         //_bt_audio_deinitialize(BT_AUDIO_ALL_MODULE);
1021
1022         a2dp_init_pending = TRUE;
1023 #endif
1024         _bt_hdp_deinit();
1025         _bt_gatt_deinit();
1026
1027         return BLUETOOTH_ERROR_NONE;
1028 }
1029
1030 /* OAL post initialization handler */
1031 static void __bt_post_oal_init(void)
1032 {
1033         int ret;
1034         int status = VCONFKEY_BT_STATUS_OFF;
1035
1036         BT_DBG("OAL initialized");
1037         if (vconf_get_int(VCONFKEY_BT_STATUS, &status) != 0)
1038                 BT_ERR("Fail to get the enabled value");
1039
1040 #if 0
1041         /* Update Bluetooth Status to OFF */
1042         if (vconf_set_int(VCONFKEY_BT_STATUS, VCONFKEY_BT_STATUS_OFF) != 0)
1043                 BT_ERR("Set vconf failed\n");
1044 #endif
1045
1046         if (status & VCONFKEY_BT_STATUS_ON) {
1047                 ret = _bt_enable_adapter();
1048                 if (ret != BLUETOOTH_ERROR_NONE)
1049                         BT_ERR("_bt_enable_adapter failed with error: %d", ret);
1050         }
1051 }
1052
1053 /* OAL initialization handler */
1054 static void __bt_handle_oal_initialisation(oal_event_t event)
1055 {
1056         BT_DBG("");
1057
1058         switch (event) {
1059         case OAL_EVENT_OAL_INITIALISED_SUCCESS:
1060                 __bt_post_oal_init();
1061                 break;
1062         case OAL_EVENT_OAL_INITIALISED_FAILED:
1063                 BT_ERR("OAL Initialisation Failed, terminate bt-service daemon..");
1064                 g_idle_add(_bt_terminate_service, NULL);
1065                 break;
1066         default:
1067                 BT_ERR("Unknown Event");
1068                 break;
1069         }
1070 }
1071
1072 static gboolean __bt_is_service_request_present(int service_function)
1073 {
1074         GSList *l;
1075         invocation_info_t *req_info;
1076
1077         BT_DBG("+");
1078
1079         /* Get method invocation context */
1080         for (l = _bt_get_invocation_list(); l != NULL; l = g_slist_next(l)) {
1081                 req_info = l->data;
1082                 if (req_info && req_info->service_function == service_function)
1083                         return TRUE;
1084         }
1085
1086         BT_DBG("-");
1087         return FALSE;
1088 }
1089
1090 /* Internal functions of core adapter service */
1091 static void __bt_adapter_handle_pending_requests(int service_function, void *user_data, unsigned int size)
1092 {
1093         GSList *l;
1094         GArray *out_param;
1095         invocation_info_t *req_info;
1096         BT_INFO("+");
1097
1098         /* Get method invocation context */
1099         for (l = _bt_get_invocation_list(); l != NULL; ) {
1100                 req_info = l->data;
1101                 l = g_slist_next(l);
1102                 if (req_info == NULL || req_info->service_function != service_function)
1103                         continue;
1104
1105                 /* Create out param */
1106                 out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
1107
1108                 switch (service_function) {
1109                 case BT_ENABLE_ADAPTER:
1110                 case BT_DISABLE_ADAPTER: {
1111                         gboolean done = TRUE;
1112                         g_array_append_vals(out_param, &done, sizeof(gboolean));
1113                         break;
1114                 }
1115                 case BT_GET_LOCAL_NAME:
1116                 case BT_GET_LOCAL_ADDRESS:
1117                 case BT_GET_LOCAL_VERSION:
1118                         g_array_append_vals(out_param, user_data, size);
1119                         break;
1120                 case BT_IS_SERVICE_USED: {
1121                         unsigned int i;
1122                         gboolean used = FALSE;
1123                         unsigned char *uuid;
1124                         char uuid_str[BT_UUID_STRING_SIZE];
1125                         char *request_uuid = req_info->user_data;
1126                         service_uuid_t *service_list = user_data;
1127
1128                         BT_INFO("Check for service uuid: %s", request_uuid);
1129                         for (i = 0; i < size; i++) {
1130                                 uuid = service_list[i].uuid;
1131                                 _bt_service_convert_uuid_type_to_string(uuid_str, uuid);
1132                                 BT_INFO("Adapter Service: [%s]", uuid_str);
1133                                 if (strcasecmp(uuid_str, request_uuid) == 0) {
1134                                         BT_INFO("UUID matched!!");
1135                                         used = TRUE;
1136                                         break;
1137                                 }
1138                         }
1139
1140                         g_array_append_vals(out_param, &used, sizeof(gboolean));
1141                         break;
1142                 }
1143                 default:
1144                         BT_ERR("Unknown service function[%d]", service_function);
1145                 }
1146
1147                 _bt_service_method_return(req_info->context, out_param, req_info->result);
1148                 g_array_free(out_param, TRUE);
1149                 /* Now free invocation info for this request*/
1150                 _bt_free_info_from_invocation_list(req_info);
1151         }
1152 }
1153
1154 static void __bt_phone_name_changed_cb(keynode_t *node, void *data)
1155 {
1156         char *phone_name = NULL;
1157         char *ptr = NULL;
1158
1159         if (node == NULL)
1160                 return;
1161
1162         if (vconf_keynode_get_type(node) == VCONF_TYPE_STRING) {
1163                 phone_name = vconf_keynode_get_str(node);
1164
1165                 if (phone_name && strlen(phone_name) != 0) {
1166                         if (!g_utf8_validate(phone_name, -1,
1167                                         (const char **)&ptr))
1168                                 *ptr = '\0';
1169
1170                         _bt_set_local_name(phone_name);
1171                 }
1172         }
1173 }
1174
1175 /* Request return handlings */
1176 static gboolean __bt_adapter_post_set_enabled(gpointer user_data)
1177 {
1178         BT_INFO("__bt_adapter_post_set_enabled>>");
1179
1180         if (TIZEN_PROFILE_TV || !headed_plugin_info->plugin_headed_enabled) {
1181                 if (BLUETOOTH_ERROR_NONE != _bt_set_discoverable_mode(
1182                                 BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE, 0))
1183                         BT_ERR("Fail to set discoverable mode");
1184         } else {
1185                 __bt_set_visible_mode();
1186         }
1187
1188         /* add the vconf noti handler */
1189         if (0 != vconf_notify_key_changed(VCONFKEY_SETAPPL_DEVICE_NAME_STR,
1190                         (vconf_callback_fn)__bt_phone_name_changed_cb, NULL))
1191                 BT_ERR("DEVICE_NAME key changed notification registration failed");
1192
1193         __bt_set_local_name();
1194
1195         /* Get All properties */
1196         if (OAL_STATUS_SUCCESS != adapter_get_properties())
1197                 BT_ERR("adapter_get_properties failed");
1198
1199         /* Add Adapter enabled post processing codes */
1200         return FALSE;
1201 }
1202
1203 static gboolean __bt_adapter_post_set_disabled(gpointer user_data)
1204 {
1205         BT_INFO("_bt_adapter_post_set_disabled>>");
1206
1207         if (!TIZEN_PROFILE_TV) {
1208                 /* Add Adapter disabled post processing codes */
1209                 if (vconf_ignore_key_changed(VCONFKEY_SETAPPL_DEVICE_NAME_STR,
1210                                 (vconf_callback_fn)__bt_phone_name_changed_cb) != 0)
1211                         BT_ERR("vconf_ignore_key_changed failed");
1212         }
1213
1214         /* bt-service should be terminated when BT is off */
1215         if (!TIZEN_FEATURE_BT_USB_DONGLE) {
1216                 /* TODO: Implement to check if it is the recovery mode or not */
1217                 _bt_reliable_terminate_service(NULL);
1218         }
1219
1220         return FALSE;
1221 }
1222
1223 static void __bt_adapter_update_bt_enabled(void)
1224 {
1225         int result = BLUETOOTH_ERROR_NONE;
1226
1227         BT_INFO("_bt_adapter_update_bt_enabled >> Init profiles...");
1228         if (BLUETOOTH_ERROR_NONE != _bt_init_profiles())
1229                 BT_ERR("Bluetooth profile init failed");
1230
1231         _bt_device_handle_adapter_state(TRUE);
1232
1233         /* Update Bluetooth Status to notify other modules */
1234         if (vconf_set_int(VCONFKEY_BT_STATUS, VCONFKEY_BT_STATUS_ON) != 0)
1235                 BT_ERR("Set vconf failed\n");
1236
1237         if (vconf_set_int(VCONFKEY_BT_DEVICE, VCONFKEY_BT_DEVICE_NONE) != 0)
1238                 BT_ERR("Set vconf failed\n");
1239
1240         /* TODO:Add timer function to handle any further post processing */
1241         g_idle_add((GSourceFunc)__bt_adapter_post_set_enabled, NULL);
1242
1243         /*Send BT Enabled event to application */
1244         _bt_send_event(BT_ADAPTER_EVENT, BLUETOOTH_EVENT_ENABLED,
1245                         g_variant_new("(i)", result));
1246 }
1247
1248 static void __bt_adapter_update_bt_disabled(void)
1249 {
1250         int result = BLUETOOTH_ERROR_NONE;
1251         int power_off_status = 0;
1252         int ret;
1253
1254         BT_INFO("_bt_adapter_update_bt_disabled >> Cleanup profiles...");
1255         _bt_cleanup_profiles();
1256
1257         _bt_device_handle_adapter_state(FALSE);
1258
1259         /* Update the vconf BT status in normal Deactivation case only */
1260         ret = vconf_get_int(VCONFKEY_SYSMAN_POWER_OFF_STATUS, &power_off_status);
1261         BT_DBG("ret : %d, power_off_status : %d", ret, power_off_status);
1262
1263         /* Update Bluetooth Status to notify other modules */
1264         if (vconf_set_int(VCONFKEY_BT_STATUS, VCONFKEY_BT_STATUS_OFF) != 0)
1265                 BT_ERR("Set vconf failed");
1266
1267         if (vconf_set_int(VCONFKEY_BT_DEVICE, VCONFKEY_BT_DEVICE_NONE) != 0)
1268                 BT_ERR("Set vconf failed\n");
1269
1270         /* TODO:Add timer function to handle any further post processing */
1271         g_idle_add((GSourceFunc)__bt_adapter_post_set_disabled, NULL);
1272
1273         /* Send BT Disabled event to application */
1274         _bt_send_event(BT_ADAPTER_EVENT, BLUETOOTH_EVENT_DISABLED,
1275                         g_variant_new("(i)", result));
1276 }
1277
1278 static void __bt_adapter_state_set_status(bt_status_t status)
1279 {
1280         BT_INFO("adapter_status changed [%d] -> [%d]", adapter_state, status);
1281         adapter_state = status;
1282 }
1283
1284 static void __bt_adapter_update_discovery_status(bt_adapter_discovery_state_t status)
1285 {
1286         BT_INFO("adapter_discovery_status changed [%d] -> [%d]", adapter_discovery_state, status);
1287         adapter_discovery_state = status;
1288 }
1289
1290 static void __bt_adapter_state_change_callback(int bt_status)
1291 {
1292         BT_INFO("__bt_adapter_state_change_callback: status [%d]", bt_status);
1293
1294         switch (bt_status) {
1295         case BT_DEACTIVATED:
1296                 __bt_adapter_state_set_status(bt_status);
1297
1298                 /* Adapter is disabled, unregister event handlers */
1299                 _bt_service_unregister_event_handler_callback(BT_ADAPTER_MODULE);
1300                 //_bt_deinit_device_event_handler();
1301
1302                 /* Add Adapter disabled post processing codes */
1303                 __bt_adapter_update_bt_disabled();
1304                 break;
1305         case BT_ACTIVATED:
1306                 __bt_adapter_state_set_status(bt_status);
1307                 /* Add Adapter enabled post processing codes */
1308                 if (timer_id > 0) {
1309                         BT_DBG("g_source is removed");
1310                         g_source_remove(timer_id);
1311                         timer_id = 0;
1312                 }
1313                 __bt_adapter_update_bt_enabled();
1314                 break;
1315         default:
1316                 BT_ERR("Incorrect Bluetooth adapter state changed status");
1317
1318         }
1319 }
1320
1321 int _bt_set_adapter_request_state(int enable)
1322 {
1323         return oal_set_adapter_request_state(enable);
1324 }
1325
1326 int _bt_set_le_request_state(int enable)
1327 {
1328         return oal_set_le_request_state(enable);
1329 }
1330
1331 static int __bt_adapter_state_handle_request(gboolean enable)
1332 {
1333         int result = BLUETOOTH_ERROR_NONE;
1334         BT_DBG("");
1335
1336         switch (adapter_state) {
1337         case BT_ACTIVATING: {
1338                 BT_INFO("Adapter is currently in activating state, state [%d]",
1339                                 adapter_state);
1340                 if (enable) {
1341                         return BLUETOOTH_ERROR_IN_PROGRESS;
1342                 } else {
1343                         if (adapter_discovery_state == ADAPTER_DISCOVERY_STARTED ||
1344                                         adapter_discovery_state == ADAPTER_DISCOVERY_STARTING) {
1345                                 /*TODO Stop Discovery*/
1346                                 __bt_adapter_update_discovery_status(FALSE);
1347                         }
1348                         result = adapter_disable();
1349                         if (result != OAL_STATUS_SUCCESS) {
1350                                 BT_ERR("adapter_enable failed: [%d]", result);
1351                                 result = BLUETOOTH_ERROR_INTERNAL;
1352                                 /*TODO: perform if anything more needs to be done to handle failure */
1353                         } else {
1354                                 /* TODO: To be handled */
1355                                 __bt_adapter_state_set_status(BT_DEACTIVATING);
1356                                 result = BLUETOOTH_ERROR_NONE;
1357                         }
1358                 }
1359                 break;
1360         }
1361         case BT_ACTIVATED: {
1362                 BT_INFO("Adapter is currently in activated state, state [%d]",
1363                                 adapter_state);
1364                 if (enable) {
1365                         return BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED;
1366                 } else {
1367                         if (adapter_discovery_state == ADAPTER_DISCOVERY_STARTED ||
1368                                         adapter_discovery_state == ADAPTER_DISCOVERY_STARTING) {
1369                                 /*TODO Stop Discovery*/
1370                                 __bt_adapter_update_discovery_status(FALSE);
1371                         }
1372                         result = adapter_disable();
1373                         if (result != OAL_STATUS_SUCCESS) {
1374                                 BT_ERR("adapter_enable failed: [%d]", result);
1375                                 result = BLUETOOTH_ERROR_INTERNAL;
1376                                 /*TODO: perform if anything more needs to be done to handle failure */
1377                         } else {
1378                                 /* TODO: To be handled */
1379                                 __bt_adapter_state_set_status(BT_DEACTIVATING);
1380                                 result = BLUETOOTH_ERROR_NONE;
1381                         }
1382                 }
1383                 break;
1384         }
1385         case BT_DEACTIVATING: {
1386                 BT_INFO("Adapter is currently in deactivating state, state [%d]",
1387                                 adapter_state);
1388                 if (!enable) {
1389                         return BLUETOOTH_ERROR_IN_PROGRESS;
1390
1391                 } else {
1392                         result = adapter_enable();
1393                         if (result != OAL_STATUS_SUCCESS && result != OAL_STATUS_PENDING) {
1394                                 BT_ERR("adapter_enable failed: [%d]", result);
1395                                 adapter_disable();
1396                                 result = BLUETOOTH_ERROR_INTERNAL;
1397                                 /*TODO: perform if anything more needs to be done to handle failure */
1398                         } else {
1399                                 /* TODO: To be handled */
1400                                 __bt_adapter_state_set_status(BT_ACTIVATING);
1401                                 result = BLUETOOTH_ERROR_NONE;
1402                         }
1403                 }
1404                 break;
1405         }
1406         case BT_DEACTIVATED: {
1407                 BT_INFO("Adapter is currently in deactivated state, state [%d]",
1408                                 adapter_state);
1409                 if (!enable) {
1410                         return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
1411                 } else {
1412                         result = adapter_enable();
1413                         if (result != OAL_STATUS_SUCCESS && result != OAL_STATUS_PENDING) {
1414                                 BT_ERR("adapter_enable failed: [%d]", result);
1415                                 adapter_disable();
1416                                 result = BLUETOOTH_ERROR_INTERNAL;
1417                                 /*TODO: perform if anything more needs to be done to handle failure */
1418                         } else {
1419                                 /* TODO: To be handled */
1420                                 __bt_adapter_state_set_status(BT_ACTIVATING);
1421                                 result = BLUETOOTH_ERROR_NONE;
1422                         }
1423                 }
1424                 break;
1425         }
1426         default:
1427                 BT_ERR("Unknown state: %d", adapter_state);
1428                 break;
1429         }
1430
1431         if (enable && result == BLUETOOTH_ERROR_NONE) {
1432                 /* Adapter enable request is successful, setup event handlers */
1433                 _bt_service_register_event_handler_callback(
1434                                 BT_ADAPTER_MODULE, __bt_adapter_event_handler);
1435                 _bt_device_state_handle_callback_set_request();
1436         }
1437         return result;
1438 }
1439
1440 static int __bt_adapter_state_discovery_request(gboolean enable,
1441                 unsigned short max_response, unsigned short duration,
1442                 unsigned int mask, gboolean is_custom,
1443                 bt_discovery_role_type_t role)
1444 {
1445         int result = BLUETOOTH_ERROR_NONE;
1446
1447         BT_DBG("+");
1448         switch (adapter_discovery_state) {
1449         case ADAPTER_DISCOVERY_STARTED: {
1450                 BT_INFO("Adapter is currently in discovery started state, state [%d]",
1451                                 adapter_discovery_state);
1452                 if (enable) {
1453                         return BLUETOOTH_ERROR_IN_PROGRESS;
1454                 } else {
1455                         result = adapter_stop_inquiry();
1456                         if (result != OAL_STATUS_SUCCESS) {
1457                                 BT_ERR("Discover stop failed: %d", result);
1458                                 result = BLUETOOTH_ERROR_INTERNAL;
1459                         } else {
1460                                 BT_ERR("Stop Discovery Triggered successfully");
1461                                 __bt_adapter_update_discovery_status(ADAPTER_DISCOVERY_STOPPING);
1462                                 result = BLUETOOTH_ERROR_NONE;
1463                         }
1464                 }
1465                 break;
1466         }
1467         case ADAPTER_DISCOVERY_STARTING: {
1468                 BT_INFO("Adapter is currently in discovery starting state, state [%d]",
1469                                 adapter_discovery_state);
1470
1471                 result = enable ?  BLUETOOTH_ERROR_IN_PROGRESS :
1472                                         BLUETOOTH_ERROR_DEVICE_BUSY;
1473
1474                 break;
1475         }
1476         case ADAPTER_DISCOVERY_STOPPED: {
1477                 BT_INFO("Adapter is currently in discovery stopped state, state [%d]",
1478                                 adapter_discovery_state);
1479                 if (!enable)
1480                         return BLUETOOTH_ERROR_NOT_IN_OPERATION;
1481                 else {
1482                         BT_DBG("max_resp: %u, duration: %u, cod: 0x%X", max_response, duration, mask);
1483
1484                         if (!is_custom)
1485                                 result = adapter_start_inquiry(duration);
1486                         else
1487                                 result = adapter_start_custom_inquiry(role);
1488
1489                         if (result != OAL_STATUS_SUCCESS) {
1490                                 BT_ERR("Start Discovery failed: %d", result);
1491                                 result = BLUETOOTH_ERROR_INTERNAL;
1492                         } else {
1493                                 BT_ERR("Start Discovery Triggered successfully");
1494                                 __bt_adapter_update_discovery_status(ADAPTER_DISCOVERY_STARTING);
1495                                 result = BLUETOOTH_ERROR_NONE;
1496                         }
1497                 }
1498                 break;
1499         }
1500         case ADAPTER_DISCOVERY_STOPPING: {
1501                 BT_INFO("Adapter is currently in discovery stopping state, state [%d]",
1502                                 adapter_discovery_state);
1503
1504                 result = enable ?  BLUETOOTH_ERROR_DEVICE_BUSY :
1505                                         BLUETOOTH_ERROR_NOT_IN_OPERATION;
1506
1507                 break;
1508         }
1509         default:
1510                 BT_ERR("Unknown state: %d", adapter_discovery_state);
1511                 break;
1512         }
1513
1514         BT_DBG("-");
1515         return result;
1516 }
1517
1518 static void __bt_adapter_discovery_state_change_callback(int bt_discovery_status)
1519 {
1520         BT_INFO("__bt_adapter_discovery_state_change_callback: status [%d]", bt_discovery_status);
1521         GVariant *param = NULL;
1522         int result = BLUETOOTH_ERROR_NONE;
1523
1524         switch (bt_discovery_status) {
1525         case ADAPTER_DISCOVERY_STOPPED:
1526         {
1527                 __bt_adapter_update_discovery_status(bt_discovery_status);
1528                 param = g_variant_new("(i)", result);
1529                 _bt_send_event(BT_ADAPTER_EVENT,
1530                                 BLUETOOTH_EVENT_DISCOVERY_FINISHED,
1531                                 param);
1532                 break;
1533         }
1534         case ADAPTER_DISCOVERY_STARTED:
1535         {
1536                 __bt_adapter_update_discovery_status(bt_discovery_status);
1537                 param = g_variant_new("(i)", result);
1538                 _bt_send_event(BT_ADAPTER_EVENT,
1539                                 BLUETOOTH_EVENT_DISCOVERY_STARTED,
1540                                 param);
1541                 break;
1542         }
1543         default:
1544                 BT_ERR("Incorrect Bluetooth adapter Discovery state changed status");
1545         }
1546 }
1547
1548 static void __bt_set_visible_mode(void)
1549 {
1550         int timeout = 0;
1551 #ifdef TIZEN_FEATURE_BT_DPM
1552         int discoverable_state = DPM_BT_ERROR;
1553 #endif
1554
1555         if (vconf_get_int(BT_FILE_VISIBLE_TIME, &timeout) != 0)
1556                 BT_ERR("Fail to get the timeout value");
1557
1558 #ifdef TIZEN_FEATURE_BT_DPM
1559         _bt_dpm_get_bluetooth_limited_discoverable_state(&discoverable_state);
1560         if (timeout == -1 || discoverable_state == DPM_RESTRICTED) {
1561                 if (_bt_set_discoverable_mode(
1562                                         BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE,
1563                                         timeout) != BLUETOOTH_ERROR_NONE) {
1564                         if (vconf_set_int(BT_FILE_VISIBLE_TIME, 0) != 0)
1565                                 BT_ERR("Set vconf failed");
1566                 }
1567         } else {
1568                 if (_bt_set_discoverable_mode(
1569                                         BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE,
1570                                         timeout) != BLUETOOTH_ERROR_NONE) {
1571                         BT_ERR("Set connectable mode failed");
1572                 }
1573         }
1574 #else
1575         if (timeout == -1) {
1576                 if (_bt_set_discoverable_mode(
1577                                         BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE,
1578                                         timeout) != BLUETOOTH_ERROR_NONE) {
1579                         if (vconf_set_int(BT_FILE_VISIBLE_TIME, 0) != 0)
1580                                 BT_ERR("Set vconf failed");
1581                 }
1582         } else {
1583                 if (_bt_set_discoverable_mode(
1584                                         BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE,
1585                                         timeout) != BLUETOOTH_ERROR_NONE) {
1586                         BT_ERR("Set connectable mode failed");
1587                 }
1588         }
1589 #endif
1590 }
1591
1592 static void __bt_set_local_name(void)
1593 {
1594         char *phone_name = NULL;
1595         char *ptr = NULL;
1596
1597         phone_name = vconf_get_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR);
1598
1599         if (!phone_name)
1600                 return;
1601
1602         if (strlen(phone_name) != 0) {
1603                 if (!g_utf8_validate(phone_name, -1, (const char **)&ptr))
1604                         *ptr = '\0';
1605
1606                 _bt_set_local_name(phone_name);
1607         }
1608         free(phone_name);
1609 }
1610
1611 void _bt_adapter_set_status(bt_status_t status)
1612 {
1613         BT_INFO("adapter_status changed [%d] -> [%d]", adapter_state, status);
1614         adapter_state = status;
1615 }
1616
1617 bt_status_t _bt_adapter_get_status(void)
1618 {
1619         return adapter_state;
1620 }
1621
1622 void _bt_set_disabled(int result)
1623 {
1624         int power_off_status = 0;
1625         int ret;
1626         int ret_pm_ignore;
1627         int pm_ignore_mode = 0;
1628
1629         ret = vconf_get_int(VCONFKEY_SYSMAN_POWER_OFF_STATUS, &power_off_status);
1630         BT_DBG("ret : %d, power_off_status : %d", ret, power_off_status);
1631
1632         ret_pm_ignore = vconf_get_int(VCONFKEY_PM_KEY_IGNORE, &pm_ignore_mode);
1633
1634         /* Update the vconf BT status in normal Deactivation case only */
1635         if (ret == 0 && power_off_status == VCONFKEY_SYSMAN_POWER_OFF_NONE &&
1636                 ret_pm_ignore == 0 && pm_ignore_mode != VCONFKEY_PM_KEY_LOCK) {
1637
1638                 BT_DBG("Update vconf for BT normal Deactivation");
1639
1640                 if (result == BLUETOOTH_ERROR_TIMEOUT)
1641                         if (vconf_set_int(BT_OFF_DUE_TO_TIMEOUT, 1) != 0)
1642                                 BT_ERR("Set vconf failed");
1643
1644                 /* Update Bluetooth Status to notify other modules */
1645                 if (vconf_set_int(VCONFKEY_BT_STATUS, VCONFKEY_BT_STATUS_OFF) != 0)
1646                         BT_ERR("Set vconf failed");
1647
1648                 if (_bt_eventsystem_set_value(SYS_EVENT_BT_STATE, EVT_KEY_BT_STATE,
1649                                                         EVT_VAL_BT_OFF) != ES_R_OK)
1650                         BT_ERR("Fail to set value");
1651         }
1652
1653         if (vconf_set_int(VCONFKEY_BT_DEVICE, VCONFKEY_BT_DEVICE_NONE) != 0)
1654                 BT_ERR("Set vconf failed\n");
1655
1656         _bt_adapter_set_status(BT_DEACTIVATED);
1657         __bt_adapter_update_discovery_status(ADAPTER_DISCOVERY_STOPPED);
1658
1659         BT_INFO("Adapter disabled");
1660 }
1661