2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
22 #include <cynara-client.h>
23 #include <cynara-creds-gdbus.h>
25 #include "bluetooth-api.h"
26 #include "bt-service-common.h"
27 #include "bt-service-util.h"
28 #include "bt-service-event.h"
29 #include "bt-service-adapter.h"
30 #include "bt-service-adapter-le.h"
31 #include "bt-service-device.h"
32 #include "bt-service-hid.h"
33 #include "bt-service-network.h"
34 #include "bt-service-audio.h"
35 #include "bt-service-oob.h"
36 #include "bt-service-avrcp.h"
37 #include "bt-service-avrcp-controller.h"
38 #include "bt-service-opp-client.h"
39 #include "bt-service-obex-server.h"
40 #include "bt-service-rfcomm-client.h"
41 #include "bt-service-rfcomm-server.h"
42 #include "bt-request-handler.h"
43 #include "bt-service-pbap.h"
44 #include "bt-service-dpm.h"
45 #include "bt-service-agent.h"
46 #include "bt-service-proximity.h"
48 static GDBusConnection *bt_service_conn;
49 static guint owner_id = 0;
51 cynara_configuration *conf;
53 static const gchar bt_service_introspection_xml[] =
54 "<node name='/org/projectx/bt_service'>"
55 " <interface name='org.projectx.bt'>"
56 " <method name='service_request'>"
57 /* Input Parameters */
58 " <arg type='i' name='service_type' direction='in' />"
59 " <arg type='i' name='service_function' direction='in' />"
60 " <arg type='i' name='request_type' direction='in' />"
61 " <arg type='ay' name='input_param1' direction='in' />"
62 " <arg type='ay' name='input_param2' direction='in' />"
63 " <arg type='ay' name='input_param3' direction='in' />"
64 " <arg type='ay' name='input_param4' direction='in' />"
65 " <arg type='ay' name='input_param5' direction='in' />"
66 /* Return Parameters */
67 " <arg type='i' name='output_param1' direction='out' />"
68 " <arg type='v' name='output_param2' direction='out' />"
73 static gboolean name_acquired = FALSE;
75 static char *current_sender_playing = NULL;
77 static void __bt_service_method(GDBusConnection *connection,
79 const gchar *object_path,
80 const gchar *interface_name,
81 const gchar *method_name,
83 GDBusMethodInvocation *invocation,
86 int __bt_bluez_request(int function_name,
89 GDBusMethodInvocation *context,
95 int __bt_obexd_request(int function_name,
98 GDBusMethodInvocation *context,
103 GArray **out_param1);
104 int __bt_agent_request(int function_name,
107 GDBusMethodInvocation *context,
112 GArray **out_param1);
113 int __bt_core_request(int function_name,
116 GDBusMethodInvocation *context,
117 GVariant *in_param1);
119 gboolean __bt_service_check_privilege(int function_name,
121 const char *unique_name);
123 /* Function definitions*/
124 static void __bt_fill_garray_from_variant(GVariant *var, GArray *param)
129 size = g_variant_get_size(var);
131 data = (char *)g_variant_get_data(var);
133 param = g_array_append_vals(param, data, size);
138 static void __bt_service_get_parameters(GVariant *in_param,
139 void *value, int size)
142 buf = (void *)g_variant_get_data(in_param);
143 memcpy(value, buf, size);
146 static void __bt_service_method(GDBusConnection *connection,
148 const gchar *object_path,
149 const gchar *interface_name,
150 const gchar *method_name,
151 GVariant *parameters,
152 GDBusMethodInvocation *invocation,
157 BT_DBG("Method[%s] Object Path[%s] Interface Name[%s]",
158 method_name, object_path, interface_name);
160 if (g_strcmp0(method_name, "service_request") == 0) {
162 int service_function;
164 GVariant *param1 = NULL;
165 GVariant *param2 = NULL;
166 GVariant *param3 = NULL;
167 GVariant *param4 = NULL;
168 GVariant *param5 = NULL;
169 GArray *out_param1 = NULL;
170 GVariant *out_var = NULL;
173 const char *sender = NULL;
175 g_variant_get(parameters, "(iii@ay@ay@ay@ay@ay)", &service_type,
176 &service_function, &request_type,
177 ¶m1, ¶m2, ¶m3, ¶m4, ¶m5);
179 out_param1 = g_array_new(FALSE, FALSE, sizeof(gchar));
181 sender = g_dbus_method_invocation_get_sender(invocation);
183 if (service_type == BT_CORE_SERVICE) {
184 BT_DBG("No need to check privilege from bt-core");
185 } else if (__bt_service_check_privilege(service_function,
186 service_type, (const char *)sender) == FALSE) {
187 BT_ERR("Client don't have the privilege to excute this function");
188 result = BLUETOOTH_ERROR_PERMISSION_DEINED;
192 if (request_type == BT_ASYNC_REQ
193 || service_function == BT_OBEX_SERVER_ACCEPT_CONNECTION) {
195 request_id = _bt_assign_request_id();
196 BT_DBG("Request ID: %d", request_id);
198 if (request_id < 0) {
199 BT_ERR("Fail to assign the request id");
200 result = BLUETOOTH_ERROR_INTERNAL;
206 BT_DBG("Service type = %s, fn = %s (0x%x)", __bt_convert_service_type_to_string(service_type),
207 _bt_convert_service_function_to_string(service_function), service_function);
208 switch (service_type) {
209 case BT_BLUEZ_SERVICE:
210 result = __bt_bluez_request(service_function,
211 request_type, request_id,
212 invocation, param1, param2,
213 param3, param4, &out_param1);
215 case BT_OBEX_SERVICE:
216 result = __bt_obexd_request(service_function,
217 request_type, request_id,
220 param4, &out_param1);
222 case BT_AGENT_SERVICE:
223 result = __bt_agent_request(service_function,
224 request_type, request_id,
227 param4, &out_param1);
229 case BT_CORE_SERVICE:
230 result = __bt_core_request(service_function,
231 request_type, request_id,
234 case BT_CHECK_PRIVILEGE:
235 result = BLUETOOTH_ERROR_NONE;
238 BT_ERR("Unknown service type");
239 result = BLUETOOTH_ERROR_INTERNAL;
243 if (result != BLUETOOTH_ERROR_NONE)
246 if ((request_type == BT_ASYNC_REQ ||
247 service_function == BT_OBEX_SERVER_ACCEPT_CONNECTION) &&
248 service_function != BT_OPP_PUSH_FILES) {
249 BT_DBG("INSERT INTO REQ LIST");
250 _bt_insert_request_list(request_id, service_function,
254 if (service_type == BT_CHECK_PRIVILEGE ||
255 service_function != BT_OPP_PUSH_FILES) {
256 out_var = g_variant_new_from_data((const GVariantType *)"ay",
257 out_param1->data, out_param1->len,
260 GVariant *temp = g_variant_new("(iv)", result, out_var);
261 g_dbus_method_invocation_return_value(invocation, temp);
265 g_array_free(out_param1, TRUE);
266 g_variant_unref(param1);
267 g_variant_unref(param2);
268 g_variant_unref(param3);
269 g_variant_unref(param4);
270 g_variant_unref(param5);
274 BT_ERR_C("Request is failed [%s] [0x%x]",
275 _bt_convert_error_to_string(result), result);
277 out_var = g_variant_new_from_data((const GVariantType *)"ay",
278 out_param1->data, out_param1->len,
281 GVariant *temp = g_variant_new("(iv)", result, out_var);
282 g_dbus_method_invocation_return_value(invocation, temp);
284 g_array_free(out_param1, TRUE);
287 if (request_type == BT_ASYNC_REQ)
288 _bt_delete_request_id(request_id);
290 g_variant_unref(param1);
291 g_variant_unref(param2);
292 g_variant_unref(param3);
293 g_variant_unref(param4);
294 g_variant_unref(param5);
302 static const GDBusInterfaceVTable method_table = {
308 int __bt_bluez_request(int function_name,
311 GDBusMethodInvocation *context,
318 int result = BLUETOOTH_ERROR_NONE;
320 switch (function_name) {
321 case BT_ENABLE_ADAPTER:
322 result = _bt_enable_adapter();
324 case BT_DISABLE_ADAPTER:
325 result = _bt_disable_adapter();
327 case BT_RECOVER_ADAPTER:
328 result = _bt_recover_adapter();
330 case BT_ENABLE_ADAPTER_LE:
331 _bt_set_le_intended_status(TRUE);
332 result = _bt_enable_adapter_le();
334 case BT_DISABLE_ADAPTER_LE:
335 _bt_set_le_intended_status(FALSE);
336 result = _bt_disable_adapter_le();
338 case BT_RESET_ADAPTER:
339 result = _bt_reset_adapter();
341 case BT_CHECK_ADAPTER: {
342 int enabled = BT_ADAPTER_DISABLED;
344 result = _bt_check_adapter(&enabled);
346 g_array_append_vals(*out_param1, &enabled,
350 case BT_GET_LOCAL_ADDRESS: {
351 bluetooth_device_address_t local_address = { {0} };
352 result = _bt_get_local_address(&local_address);
354 g_array_append_vals(*out_param1, &local_address,
355 sizeof(bluetooth_device_address_t));
358 case BT_GET_LOCAL_VERSION: {
359 bluetooth_version_t ver = { {0} };
360 result = _bt_get_local_version(&ver);
362 g_array_append_vals(*out_param1, &ver,
363 sizeof(bluetooth_version_t));
366 case BT_GET_LOCAL_NAME: {
367 bluetooth_device_name_t local_name = { {0} };
368 result = _bt_get_local_name(&local_name);
370 g_array_append_vals(*out_param1, &local_name,
371 sizeof(bluetooth_device_name_t));
375 case BT_SET_LOCAL_NAME: {
376 bluetooth_device_name_t local_name = { {0} };
377 __bt_service_get_parameters(in_param1,
378 &local_name, sizeof(bluetooth_device_name_t));
380 result = _bt_set_local_name(local_name.name);
384 case BT_IS_SERVICE_USED: {
386 gboolean used = FALSE;
388 uuid = (char *)g_variant_get_data(in_param1);
390 result = _bt_is_service_used(uuid, &used);
392 if (result == BLUETOOTH_ERROR_NONE) {
393 g_array_append_vals(*out_param1, &used,
398 case BT_GET_DISCOVERABLE_MODE: {
399 int mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
401 result = _bt_get_discoverable_mode(&mode);
403 g_array_append_vals(*out_param1, &mode, sizeof(int));
406 case BT_SET_DISCOVERABLE_MODE: {
407 int mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
410 __bt_service_get_parameters(in_param1, &mode, sizeof(int));
411 __bt_service_get_parameters(in_param2, &time, sizeof(int));
413 result = _bt_set_discoverable_mode(mode, time);
416 case BT_GET_DISCOVERABLE_TIME: {
419 result = _bt_get_timeout_value(&timeout);
421 g_array_append_vals(*out_param1, &timeout, sizeof(int));
424 case BT_START_DISCOVERY:
425 result = _bt_start_discovery();
428 case BT_START_CUSTOM_DISCOVERY: {
429 bt_discovery_role_type_t role;
431 __bt_service_get_parameters(in_param1,
432 &role, sizeof(bt_discovery_role_type_t));
433 result = _bt_start_custom_discovery(role);
437 case BT_CANCEL_DISCOVERY:
438 result = _bt_cancel_discovery();
440 case BT_IS_DISCOVERYING: {
441 gboolean discovering = FALSE;
442 discovering = _bt_is_discovering();
443 g_array_append_vals(*out_param1,
444 &discovering, sizeof(gboolean));
447 case BT_START_LE_DISCOVERY: {
450 sender = (char *)g_dbus_method_invocation_get_sender(context);
451 result = _bt_start_le_scan(sender);
455 case BT_STOP_LE_DISCOVERY: {
458 sender = (char *)g_dbus_method_invocation_get_sender(context);
459 result = _bt_stop_le_scan(sender);
463 case BT_IS_LE_DISCOVERYING: {
464 gboolean le_discovering = FALSE;
466 le_discovering = _bt_is_le_scanning();
467 g_array_append_vals(*out_param1,
468 &le_discovering, sizeof(gboolean));
472 case BT_REGISTER_SCAN_FILTER: {
474 bluetooth_le_scan_filter_t scan_filter;
476 sender = (char *)g_dbus_method_invocation_get_sender(context);
477 __bt_service_get_parameters(in_param1, &scan_filter,
478 sizeof(bluetooth_le_scan_filter_t));
479 BT_DBG("bluetooth_le_scan_filter_t [features : %.2x]",
480 scan_filter.added_features);
482 result = _bt_register_scan_filter(sender,
487 case BT_IS_SCAN_FILTER_SUPPORTED:{
488 int is_supported = 0;
490 if (_bt_is_scan_filter_supported() == TRUE)
493 g_array_append_vals(*out_param1,
494 &is_supported, sizeof(int));
498 case BT_ENABLE_RSSI: {
499 bluetooth_device_address_t bd_addr;
501 bt_rssi_threshold_t rssi_threshold;
503 int in_range_threshold;
506 BT_DBG("Enable RSSI");
508 __bt_service_get_parameters(in_param1,
509 &bd_addr, sizeof(bluetooth_device_address_t));
510 __bt_service_get_parameters(in_param2,
511 &link_type, sizeof(int));
512 __bt_service_get_parameters(in_param3,
513 &rssi_threshold, sizeof(bt_rssi_threshold_t));
515 low_threshold = rssi_threshold.low_threshold;
516 in_range_threshold = rssi_threshold.in_range_threshold;
517 high_threshold = rssi_threshold.high_threshold;
519 result = _bt_enable_rssi(&bd_addr,
520 link_type, low_threshold,
521 in_range_threshold, high_threshold);
526 bluetooth_device_address_t bd_addr;
528 BT_DBG("Get RSSI Strength");
530 __bt_service_get_parameters(in_param1,
531 &bd_addr, sizeof(bluetooth_device_address_t));
532 __bt_service_get_parameters(in_param2,
533 &link_type, sizeof(int));
535 result = _bt_get_rssi_strength(&bd_addr, link_type);
538 case BT_IS_CONNECTABLE: {
539 gboolean is_connectable;
541 is_connectable = _bt_is_connectable();
542 g_array_append_vals(*out_param1,
543 &is_connectable, sizeof(gboolean));
546 case BT_SET_CONNECTABLE: {
547 gboolean is_connectable;
549 __bt_service_get_parameters(in_param1,
550 &is_connectable, sizeof(gboolean));
551 result = _bt_set_connectable(is_connectable);
554 case BT_SET_ADVERTISING: {
557 gboolean enable = FALSE;
558 gboolean use_reserved_slot = FALSE;
560 __bt_service_get_parameters(in_param1,
561 &adv_handle, sizeof(int));
562 __bt_service_get_parameters(in_param2,
563 &enable, sizeof(gboolean));
564 __bt_service_get_parameters(in_param3,
565 &use_reserved_slot, sizeof(gboolean));
567 sender = (char *)g_dbus_method_invocation_get_sender(context);
569 result = _bt_set_advertising(sender, adv_handle,
570 enable, use_reserved_slot);
573 case BT_SET_CUSTOM_ADVERTISING: {
576 gboolean enable = FALSE;
577 bluetooth_advertising_params_t adv_params;
578 gboolean use_reserved_slot = FALSE;
580 sender = (char *)g_dbus_method_invocation_get_sender(context);
582 __bt_service_get_parameters(in_param1, &adv_handle,
584 __bt_service_get_parameters(in_param2, &enable,
586 __bt_service_get_parameters(in_param3, &adv_params,
587 sizeof(bluetooth_advertising_params_t));
588 __bt_service_get_parameters(in_param4, &use_reserved_slot,
591 BT_DBG("bluetooth_advertising_params_t [%f %f %d %d %d]",
592 adv_params.interval_min, adv_params.interval_max,
593 adv_params.filter_policy, adv_params.type, adv_params.tx_power_level);
594 result = _bt_set_custom_advertising(sender, adv_handle,
595 enable, &adv_params, use_reserved_slot);
598 case BT_GET_ADVERTISING_DATA: {
599 bluetooth_advertising_data_t adv = { {0} };
602 result = _bt_get_advertising_data(&adv, &length);
603 if (result == BLUETOOTH_ERROR_NONE)
604 g_array_append_vals(*out_param1, adv.data, length);
608 case BT_SET_ADVERTISING_DATA: {
611 bluetooth_advertising_data_t adv = { {0} };
613 gboolean use_reserved_slot = FALSE;
615 sender = (char *)g_dbus_method_invocation_get_sender(context);
617 __bt_service_get_parameters(in_param1,
618 &adv_handle, sizeof(int));
619 __bt_service_get_parameters(in_param2,
620 &adv, sizeof(bluetooth_advertising_data_t));
621 __bt_service_get_parameters(in_param3,
622 &length, sizeof(int));
623 __bt_service_get_parameters(in_param4,
624 &use_reserved_slot, sizeof(gboolean));
626 result = _bt_set_advertising_data(sender, adv_handle,
627 &adv, length, use_reserved_slot);
630 case BT_GET_SCAN_RESPONSE_DATA: {
631 bluetooth_scan_resp_data_t rsp = { {0} };
634 result = _bt_get_scan_response_data(&rsp, &length);
635 if (result == BLUETOOTH_ERROR_NONE)
636 g_array_append_vals(*out_param1, rsp.data, length);
640 case BT_SET_SCAN_RESPONSE_DATA: {
643 bluetooth_scan_resp_data_t rsp = { {0} };
645 gboolean use_reserved_slot = FALSE;
647 sender = (char *)g_dbus_method_invocation_get_sender(context);
649 __bt_service_get_parameters(in_param1,
650 &adv_handle, sizeof(int));
651 __bt_service_get_parameters(in_param2,
652 &rsp, sizeof(bluetooth_scan_resp_data_t));
653 __bt_service_get_parameters(in_param3,
654 &length, sizeof(int));
655 __bt_service_get_parameters(in_param4,
656 &use_reserved_slot, sizeof(gboolean));
658 result = _bt_set_scan_response_data(sender, adv_handle,
659 &rsp, length, use_reserved_slot);
663 case BT_SET_MANUFACTURER_DATA: {
664 bluetooth_manufacturer_data_t m_data = { 0 };
665 __bt_service_get_parameters(in_param1,
666 &m_data, sizeof(bluetooth_manufacturer_data_t));
668 result = _bt_set_manufacturer_data(&m_data);
671 case BT_SET_SCAN_PARAMETERS: {
672 bluetooth_le_scan_params_t scan_params;
673 __bt_service_get_parameters(in_param1, &scan_params,
674 sizeof(bluetooth_le_scan_params_t));
676 BT_DBG("bluetooth_le_scan_params_t [%f %f %d]",
677 scan_params.interval, scan_params.window,
680 result = _bt_prepare_scan_parameters(&scan_params, 0);
683 case BT_SET_SCAN_TYPE: {
685 __bt_service_get_parameters(in_param1, &scan_type, sizeof(int));
687 BT_DBG("bluetooth_le_scan_type [%d]", scan_type);
688 result = _bt_prepare_scan_parameters(NULL, scan_type);
691 case BT_LE_CONN_UPDATE: {
693 bluetooth_device_address_t local_address = { {0} };
694 bluetooth_le_connection_param_t parameters = {0};
696 sender = (char *)g_dbus_method_invocation_get_sender(context);
698 __bt_service_get_parameters(in_param1, &local_address,
699 sizeof(bluetooth_device_address_t));
700 __bt_service_get_parameters(in_param2, ¶meters,
701 sizeof(bluetooth_le_connection_param_t));
703 result = _bt_le_conn_update(sender,
705 parameters.interval_min,
706 parameters.interval_max,
711 case BT_IS_ADVERTISING: {
712 gboolean advertising = FALSE;
713 advertising = _bt_is_advertising();
715 g_array_append_vals(*out_param1, &advertising,
719 case BT_ADD_WHITE_LIST: {
720 bluetooth_device_address_t address = { {0} };
723 __bt_service_get_parameters(in_param1, &address,
724 sizeof(bluetooth_device_address_t));
725 __bt_service_get_parameters(in_param2, &addr_type,
728 result = _bt_add_white_list(&address, addr_type);
731 case BT_REMOVE_WHITE_LIST: {
732 bluetooth_device_address_t address = { {0} };
735 __bt_service_get_parameters(in_param1,
736 &address, sizeof(bluetooth_device_address_t));
737 __bt_service_get_parameters(in_param2,
738 &addr_type, sizeof(int));
740 result = _bt_remove_white_list(&address, addr_type);
743 case BT_CLEAR_WHITE_LIST: {
744 result = _bt_clear_white_list();
747 case BT_GET_BONDED_DEVICES: {
748 result = _bt_get_bonded_devices(out_param1);
751 case BT_GET_PROFILE_CONNECTED_DEVICES: {
753 uuid = (char *)g_variant_get_data(in_param1);
754 result = _bt_get_profile_connected_devices(uuid, out_param1);
757 case BT_SET_PASSKEY_NOTIFICATION: {
761 sender = (char *)g_dbus_method_invocation_get_sender(context);
762 __bt_service_get_parameters(in_param1,
763 &enable, sizeof(gboolean));
765 result = _bt_set_passkey_notification(sender, enable);
768 case BT_GET_BONDED_DEVICE: {
769 bluetooth_device_address_t address = { {0} };
770 bluetooth_device_info_t dev_info;
772 __bt_service_get_parameters(in_param1,
773 &address, sizeof(bluetooth_device_address_t));
775 memset(&dev_info, 0x00, sizeof(bluetooth_device_info_t));
776 result = _bt_get_bonded_device_info(&address, &dev_info);
778 if (result == BLUETOOTH_ERROR_NONE) {
779 g_array_append_vals(*out_param1, &dev_info,
780 sizeof(bluetooth_device_info_t));
784 case BT_GET_IS_ALIAS_SET: {
785 bluetooth_device_address_t address = { {0} };
786 gboolean is_alias_set = FALSE;
788 __bt_service_get_parameters(in_param1,
789 &address, sizeof(bluetooth_device_address_t));
791 result = _bt_is_alias_set(&address, &is_alias_set);
792 if (result == BLUETOOTH_ERROR_NONE)
793 g_array_append_vals(*out_param1, &is_alias_set, sizeof(gboolean));
797 case BT_DISCONNECT_DEVICE: {
798 bluetooth_device_address_t addr = { {0} };
799 char address[BLUETOOTH_ADDRESS_STRING_LENGTH + 1];
801 __bt_service_get_parameters(in_param1,
802 &addr, sizeof(bluetooth_device_address_t));
803 _bt_convert_addr_type_to_string(address, addr.addr);
805 result = _bt_disconnect_all(address);
808 case BT_BOND_DEVICE: {
809 bluetooth_device_address_t address = { {0} };
811 __bt_service_get_parameters(in_param1,
812 &address, sizeof(bluetooth_device_address_t));
814 result = _bt_bond_device(request_id, &address,
815 BLUETOOTH_DEV_CONN_DEFAULT, out_param1);
818 case BT_BOND_DEVICE_BY_TYPE: {
819 bluetooth_device_address_t address = { {0} };
820 unsigned short conn_type = 0;
822 __bt_service_get_parameters(in_param1,
823 &address, sizeof(bluetooth_device_address_t));
824 __bt_service_get_parameters(in_param2,
825 &conn_type, sizeof(unsigned short));
827 result = _bt_bond_device(request_id, &address,
828 conn_type, out_param1);
831 case BT_CANCEL_BONDING: {
832 result = _bt_cancel_bonding();
835 case BT_PASSKEY_REPLY: {
836 const char *passkey = NULL;
837 gboolean authentication_reply = FALSE;
839 passkey = g_variant_get_data(in_param1);
840 __bt_service_get_parameters(in_param2,
841 &authentication_reply, sizeof(gboolean));
842 result = _bt_passkey_reply(passkey, authentication_reply);
845 case BT_PASSKEY_CONFIRMATION_REPLY: {
846 gboolean confirmation_reply = FALSE;
848 __bt_service_get_parameters(in_param1,
849 &confirmation_reply, sizeof(gboolean));
850 result = _bt_passkey_confirmation_reply(confirmation_reply);
853 case BT_UNBOND_DEVICE: {
854 bluetooth_device_address_t address = { {0} };
856 __bt_service_get_parameters(in_param1,
857 &address, sizeof(bluetooth_device_address_t));
859 result = _bt_unbond_device(request_id, &address, out_param1);
864 bluetooth_device_address_t address = { {0} };
865 const char *local_name;
867 __bt_service_get_parameters(in_param1,
868 &address, sizeof(bluetooth_device_address_t));
869 local_name = (const char *)g_variant_get_data(in_param2);
871 result = _bt_set_alias(&address, local_name);
874 case BT_SEARCH_SERVICE: {
875 bluetooth_device_address_t address = { {0} };
877 __bt_service_get_parameters(in_param1,
878 &address, sizeof(bluetooth_device_address_t));
880 result = _bt_search_device(request_id, &address);
881 if (result != BLUETOOTH_ERROR_NONE) {
882 g_array_append_vals(*out_param1, &address,
883 sizeof(bluetooth_device_address_t));
887 case BT_CANCEL_SEARCH_SERVICE: {
888 result = _bt_cancel_search_device();
891 case BT_SET_AUTHORIZATION: {
892 bluetooth_device_address_t address = { {0} };
895 __bt_service_get_parameters(in_param1,
896 &address, sizeof(bluetooth_device_address_t));
897 __bt_service_get_parameters(in_param2,
898 &authorize, sizeof(gboolean));
900 result = _bt_set_authorization(&address, authorize);
903 case BT_IS_DEVICE_CONNECTED: {
904 bluetooth_device_address_t address = { {0} };
906 gboolean connected = FALSE;
908 __bt_service_get_parameters(in_param1,
909 &address, sizeof(bluetooth_device_address_t));
910 __bt_service_get_parameters(in_param2,
913 result = _bt_is_device_connected(&address, type, &connected);
914 BT_DBG("is_connected: %d", connected);
915 if (result == BLUETOOTH_ERROR_NONE) {
916 g_array_append_vals(*out_param1, &connected,
922 case BT_GET_CONNECTED_LINK_TYPE: {
923 bluetooth_device_address_t address = { {0} };
924 bluetooth_connected_link_t connected = BLUETOOTH_CONNECTED_LINK_NONE;
926 __bt_service_get_parameters(in_param1,
927 &address, sizeof(bluetooth_device_address_t));
929 result = _bt_get_connected_link(&address, &connected);
931 if (result == BLUETOOTH_ERROR_NONE) {
932 g_array_append_vals(*out_param1, &connected,
938 case BT_SET_PIN_CODE: {
939 bluetooth_device_address_t address = { {0} };
940 bluetooth_device_pin_code_t pin_code = { {0} };
942 __bt_service_get_parameters(in_param1,
943 &address, sizeof(bluetooth_device_address_t));
944 __bt_service_get_parameters(in_param2,
945 &pin_code, sizeof(bluetooth_device_pin_code_t));
947 result = _bt_set_pin_code(&address, &pin_code);
950 case BT_UNSET_PIN_CODE: {
951 bluetooth_device_address_t address = { {0} };
953 __bt_service_get_parameters(in_param1,
954 &address, sizeof(bluetooth_device_address_t));
956 result = _bt_unset_pin_code(&address);
959 case BT_UPDATE_LE_CONNECTION_MODE: {
961 bluetooth_device_address_t remote_address = { { 0 } };
962 bluetooth_le_connection_param_t param = { 0 };
963 bluetooth_le_connection_mode_t mode = BLUETOOTH_LE_CONNECTION_MODE_BALANCED;
965 __bt_service_get_parameters(in_param1, &remote_address,
966 sizeof(bluetooth_device_address_t));
967 __bt_service_get_parameters(in_param2, &mode,
968 sizeof(bluetooth_le_connection_mode_t));
970 result = _bt_get_le_connection_parameter(mode, ¶m);
971 if (result != BLUETOOTH_ERROR_NONE)
974 sender = (char *)g_dbus_method_invocation_get_sender(context);
976 result = _bt_le_conn_update(sender,
985 case BT_SET_PROFILE_TRUSTED: {
986 bluetooth_device_address_t bd_addr = { {0} };
990 __bt_service_get_parameters(in_param1, &bd_addr,
991 sizeof(bluetooth_device_address_t));
992 __bt_service_get_parameters(in_param2, &profile, sizeof(int));
993 __bt_service_get_parameters(in_param3, &trust, sizeof(int));
995 result = _bt_set_trust_profile(&bd_addr, profile, trust);
998 case BT_GET_PROFILE_TRUSTED: {
999 bluetooth_device_address_t bd_addr = { {0} };
1001 guint trusted_profile = 0;
1003 __bt_service_get_parameters(in_param1, &bd_addr,
1004 sizeof(bluetooth_device_address_t));
1005 __bt_service_get_parameters(in_param2, &profile, sizeof(int));
1007 result = _bt_get_trust_profile(&bd_addr, profile, &trusted_profile);
1008 BT_DBG("TRUST %d", trusted_profile);
1009 if (result == BLUETOOTH_ERROR_NONE) {
1010 g_array_append_vals(*out_param1, &trusted_profile,
1016 case BT_SET_PROFILE_RESTRICTED: {
1017 bluetooth_device_address_t bd_addr = { {0} };
1021 __bt_service_get_parameters(in_param1, &bd_addr,
1022 sizeof(bluetooth_device_address_t));
1023 __bt_service_get_parameters(in_param2, &profile, sizeof(int));
1024 __bt_service_get_parameters(in_param3, &restricted, sizeof(int));
1026 result = _bt_set_restrict_profile(&bd_addr, profile, restricted);
1029 case BT_GET_PROFILE_RESTRICTED: {
1030 bluetooth_device_address_t bd_addr = { {0} };
1032 guint restricted_profile = 0;
1034 __bt_service_get_parameters(in_param1, &bd_addr,
1035 sizeof(bluetooth_device_address_t));
1036 __bt_service_get_parameters(in_param2, &profile, sizeof(int));
1038 result = _bt_get_restrict_profile(&bd_addr, profile, &restricted_profile);
1039 BT_DBG("Restricted %d", restricted_profile);
1040 if (result == BLUETOOTH_ERROR_NONE) {
1041 g_array_append_vals(*out_param1, &restricted_profile,
1047 case BT_HID_CONNECT: {
1048 bluetooth_device_address_t address = { {0} };
1050 __bt_service_get_parameters(in_param1,
1051 &address, sizeof(bluetooth_device_address_t));
1053 result = _bt_hid_connect(request_id, &address);
1054 if (result != BLUETOOTH_ERROR_NONE) {
1055 g_array_append_vals(*out_param1, &address,
1056 sizeof(bluetooth_device_address_t));
1060 case BT_HID_DISCONNECT: {
1061 bluetooth_device_address_t address = { {0} };
1063 __bt_service_get_parameters(in_param1,
1064 &address, sizeof(bluetooth_device_address_t));
1066 result = _bt_hid_disconnect(request_id, &address);
1067 if (result != BLUETOOTH_ERROR_NONE) {
1068 g_array_append_vals(*out_param1, &address,
1069 sizeof(bluetooth_device_address_t));
1073 case BT_HID_ENABLE_BARCODE_FEATURE: {
1074 result = _bt_hid_enable_barcode_feature();
1077 case BT_NETWORK_ACTIVATE:
1078 result = _bt_network_activate();
1080 case BT_NETWORK_DEACTIVATE:
1081 result = _bt_network_deactivate();
1083 case BT_NETWORK_CONNECT: {
1084 bluetooth_device_address_t address = { {0} };
1087 __bt_service_get_parameters(in_param1,
1088 &address, sizeof(bluetooth_device_address_t));
1089 __bt_service_get_parameters(in_param2,
1090 &role, sizeof(int));
1092 result = _bt_network_connect(request_id, role, &address);
1093 if (result != BLUETOOTH_ERROR_NONE) {
1094 g_array_append_vals(*out_param1, &address,
1095 sizeof(bluetooth_device_address_t));
1099 case BT_NETWORK_DISCONNECT: {
1100 bluetooth_device_address_t address = { {0} };
1102 __bt_service_get_parameters(in_param1,
1103 &address, sizeof(bluetooth_device_address_t));
1105 result = _bt_network_disconnect(request_id, &address);
1106 if (result != BLUETOOTH_ERROR_NONE) {
1107 g_array_append_vals(*out_param1, &address,
1108 sizeof(bluetooth_device_address_t));
1112 case BT_NETWORK_SERVER_DISCONNECT: {
1113 bluetooth_device_address_t address = { {0} };
1115 __bt_service_get_parameters(in_param1,
1116 &address, sizeof(bluetooth_device_address_t));
1118 result = _bt_network_server_disconnect(request_id, &address);
1119 if (result != BLUETOOTH_ERROR_NONE) {
1120 g_array_append_vals(*out_param1, &address,
1121 sizeof(bluetooth_device_address_t));
1126 case BT_AUDIO_CONNECT: {
1127 bluetooth_device_address_t address = { {0} };
1129 __bt_service_get_parameters(in_param1,
1130 &address, sizeof(bluetooth_device_address_t));
1132 result = _bt_audio_connect(request_id, BT_AUDIO_ALL,
1133 &address, *out_param1);
1136 case BT_AUDIO_DISCONNECT: {
1137 bluetooth_device_address_t address = { {0} };
1139 __bt_service_get_parameters(in_param1,
1140 &address, sizeof(bluetooth_device_address_t));
1142 result = _bt_audio_disconnect(request_id, BT_AUDIO_ALL,
1143 &address, *out_param1);
1146 case BT_AG_CONNECT: {
1147 bluetooth_device_address_t address = { {0} };
1149 __bt_service_get_parameters(in_param1,
1150 &address, sizeof(bluetooth_device_address_t));
1152 result = _bt_audio_connect(request_id, BT_AUDIO_HSP,
1153 &address, *out_param1);
1156 case BT_AG_DISCONNECT: {
1157 bluetooth_device_address_t address = { {0} };
1159 __bt_service_get_parameters(in_param1,
1160 &address, sizeof(bluetooth_device_address_t));
1162 result = _bt_audio_disconnect(request_id, BT_AUDIO_HSP,
1163 &address, *out_param1);
1166 case BT_AV_CONNECT: {
1167 bluetooth_device_address_t address = { {0} };
1169 __bt_service_get_parameters(in_param1,
1170 &address, sizeof(bluetooth_device_address_t));
1172 result = _bt_audio_connect(request_id, BT_AUDIO_A2DP,
1173 &address, *out_param1);
1176 case BT_AV_DISCONNECT: {
1177 bluetooth_device_address_t address = { {0} };
1179 __bt_service_get_parameters(in_param1,
1180 &address, sizeof(bluetooth_device_address_t));
1182 result = _bt_audio_disconnect(request_id, BT_AUDIO_A2DP,
1183 &address, *out_param1);
1186 case BT_AVRCP_CONTROL_CONNECT: {
1187 bluetooth_device_address_t address = { {0} };
1189 __bt_service_get_parameters(in_param1,
1190 &address, sizeof(bluetooth_device_address_t));
1192 result = _bt_audio_connect(request_id, BT_AVRCP,
1193 &address, *out_param1);
1196 case BT_AVRCP_CONTROL_DISCONNECT: {
1197 bluetooth_device_address_t address = { {0} };
1199 __bt_service_get_parameters(in_param1,
1200 &address, sizeof(bluetooth_device_address_t));
1202 result = _bt_audio_disconnect(request_id, BT_AVRCP,
1203 &address, *out_param1);
1206 case BT_AVRCP_TARGET_CONNECT: {
1207 bluetooth_device_address_t address = { {0} };
1208 __bt_service_get_parameters(in_param1,
1209 &address, sizeof(bluetooth_device_address_t));
1210 result = _bt_audio_connect(request_id, BT_AVRCP_TARGET,
1211 &address, *out_param1);
1214 case BT_AVRCP_TARGET_DISCONNECT: {
1215 bluetooth_device_address_t address = { {0} };
1216 __bt_service_get_parameters(in_param1,
1217 &address, sizeof(bluetooth_device_address_t));
1218 result = _bt_audio_disconnect(request_id, BT_AVRCP_TARGET,
1219 &address, *out_param1);
1222 case BT_AV_SOURCE_CONNECT: {
1223 bluetooth_device_address_t address = { {0} };
1225 __bt_service_get_parameters(in_param1, &address,
1226 sizeof(bluetooth_device_address_t));
1228 result = _bt_audio_connect(request_id, BT_AUDIO_A2DP_SOURCE,
1229 &address, *out_param1);
1232 case BT_AV_SOURCE_DISCONNECT: {
1233 bluetooth_device_address_t address = { {0} };
1235 __bt_service_get_parameters(in_param1, &address,
1236 sizeof(bluetooth_device_address_t));
1238 result = _bt_audio_disconnect(request_id, BT_AUDIO_A2DP_SOURCE,
1239 &address, *out_param1);
1242 case BT_HF_CONNECT: {
1243 bluetooth_device_address_t address = { {0} };
1245 __bt_service_get_parameters(in_param1,
1246 &address, sizeof(bluetooth_device_address_t));
1248 result = _bt_hf_connect(request_id, &address, *out_param1);
1251 case BT_HF_DISCONNECT: {
1252 bluetooth_device_address_t address = { {0} };
1254 __bt_service_get_parameters(in_param1,
1255 &address, sizeof(bluetooth_device_address_t));
1257 result = _bt_hf_disconnect(request_id, &address, *out_param1);
1260 case BT_SET_CONTENT_PROTECT: {
1263 __bt_service_get_parameters(in_param1,
1264 &status, sizeof(gboolean));
1266 result = _bt_audio_set_content_protect(status);
1270 case BT_OOB_READ_LOCAL_DATA: {
1271 bt_oob_data_t local_oob_data;
1273 memset(&local_oob_data, 0x00, sizeof(bt_oob_data_t));
1274 result = _bt_oob_read_local_data(&local_oob_data);
1276 g_array_append_vals(*out_param1, &local_oob_data,
1277 sizeof(bt_oob_data_t));
1281 case BT_OOB_ADD_REMOTE_DATA: {
1282 bluetooth_device_address_t address = { {0} };
1283 bt_oob_data_t remote_oob_data;
1285 __bt_service_get_parameters(in_param1,
1286 &address, sizeof(bluetooth_device_address_t));
1287 __bt_service_get_parameters(in_param2,
1288 &remote_oob_data, sizeof(bt_oob_data_t));
1290 result = _bt_oob_add_remote_data(&address, &remote_oob_data);
1294 case BT_OOB_REMOVE_REMOTE_DATA: {
1295 bluetooth_device_address_t address = { {0} };
1297 __bt_service_get_parameters(in_param1,
1298 &address, sizeof(bluetooth_device_address_t));
1300 result = _bt_oob_remove_remote_data(&address);
1304 case BT_LE_OOB_READ_LOCAL_DATA: {
1305 bt_oob_data_t local_oob_data;
1307 memset(&local_oob_data, 0x00, sizeof(bt_oob_data_t));
1308 result = _bt_le_oob_read_local_data(&local_oob_data);
1310 g_array_append_vals(*out_param1, &local_oob_data,
1311 sizeof(bt_oob_data_t));
1315 case BT_LE_OOB_ADD_REMOTE_DATA: {
1316 bluetooth_device_address_t address = { {0} };
1317 unsigned short address_type;
1318 bt_oob_data_t remote_oob_data;
1320 __bt_service_get_parameters(in_param1,
1321 &address, sizeof(bluetooth_device_address_t));
1322 __bt_service_get_parameters(in_param2,
1323 &address_type, sizeof(unsigned short));
1324 __bt_service_get_parameters(in_param3,
1325 &remote_oob_data, sizeof(bt_oob_data_t));
1327 result = _bt_oob_add_remote_data(&address, address_type, &remote_oob_data);
1331 case BT_AVRCP_SET_TRACK_INFO: {
1332 media_metadata_t data;
1333 media_metadata_attributes_t meta_data;
1335 memset(&data, 0x00, sizeof(media_metadata_t));
1336 memset(&meta_data, 0x00, sizeof(media_metadata_attributes_t));
1338 __bt_service_get_parameters(in_param1,
1339 &data, sizeof(media_metadata_t));
1341 meta_data.title = g_strdup(data.title);
1342 meta_data.artist = g_strdup(data.artist);
1343 meta_data.album = g_strdup(data.album);
1344 meta_data.genre = g_strdup(data.genre);
1345 meta_data.total_tracks = data.total_tracks;
1346 meta_data.number = data.number;
1347 meta_data.duration = (int64_t) data.duration;
1349 if (meta_data.title)
1350 BT_INFO("title [%s]", meta_data.title);
1351 if (meta_data.artist)
1352 BT_INFO("artist [%s]", meta_data.artist);
1353 if (meta_data.album)
1354 BT_INFO("album [%s]", meta_data.album);
1355 if (meta_data.genre)
1356 BT_INFO("genre [%s]", meta_data.genre);
1357 BT_INFO("total_tracks[%d], number[%d], duration[%d]",
1358 meta_data.total_tracks, meta_data.number, meta_data.duration);
1360 result = _bt_avrcp_set_track_info(&meta_data);
1362 g_free((gpointer)meta_data.title);
1363 g_free((gpointer)meta_data.artist);
1364 g_free((gpointer)meta_data.album);
1365 g_free((gpointer)meta_data.genre);
1369 case BT_AVRCP_SET_PROPERTY: {
1372 char *sender = NULL;
1373 sender = (char *)g_dbus_method_invocation_get_sender(context);
1374 BT_INFO("Sender %s", sender);
1376 __bt_service_get_parameters(in_param1,
1377 &type, sizeof(int));
1378 __bt_service_get_parameters(in_param2,
1379 &value, sizeof(unsigned int));
1381 if (value == STATUS_PLAYING) {
1382 if (current_sender_playing)
1383 g_free(current_sender_playing);
1384 current_sender_playing = g_strdup(sender);
1386 if (g_strcmp0(sender, current_sender_playing) == 0 ||
1387 current_sender_playing == NULL) {
1388 BT_INFO("Current Player Status %d type %d", value, type);
1390 BT_INFO("Current Player and this sender are different");
1391 result = BLUETOOTH_ERROR_NONE;
1394 result = _bt_avrcp_set_property(type, value);
1398 case BT_AVRCP_SET_PROPERTIES: {
1399 media_player_settings_t properties;
1401 memset(&properties, 0x00, sizeof(media_player_settings_t));
1402 __bt_service_get_parameters(in_param1,
1403 &properties, sizeof(media_player_settings_t));
1405 result = _bt_avrcp_set_properties(&properties);
1409 case BT_AVRCP_HANDLE_CONTROL: {
1412 __bt_service_get_parameters(in_param1, &type, sizeof(int));
1414 result = _bt_avrcp_control_cmd(type);
1418 case BT_AVRCP_CONTROL_SET_PROPERTY: {
1422 __bt_service_get_parameters(in_param1,
1423 &type, sizeof(int));
1424 __bt_service_get_parameters(in_param2,
1425 &value, sizeof(unsigned int));
1427 result = _bt_avrcp_control_set_property(type, value);
1431 case BT_AVRCP_CONTROL_GET_PROPERTY: {
1435 __bt_service_get_parameters(in_param1, &type, sizeof(int));
1437 result = _bt_avrcp_control_get_property(type, &value);
1438 g_array_append_vals(*out_param1, &value, sizeof(int));
1442 case BT_AVRCP_GET_TRACK_INFO: {
1443 media_metadata_t meta_data;
1444 media_metadata_attributes_t metadata;
1446 memset(&meta_data, 0x00, sizeof(media_metadata_t));
1447 memset(&metadata, 0x00, sizeof(media_metadata_attributes_t));
1449 result = _bt_avrcp_control_get_track_info(&metadata);
1451 if (BLUETOOTH_ERROR_NONE != result)
1454 if (_bt_copy_utf8_string(meta_data.title, metadata.title,
1455 BT_META_DATA_MAX_LEN))
1456 BT_ERR("Error in copying Title\n");
1457 if (_bt_copy_utf8_string(meta_data.artist, metadata.artist,
1458 BT_META_DATA_MAX_LEN))
1459 BT_ERR("Error in copying Artist\n");
1460 if (_bt_copy_utf8_string(meta_data.album, metadata.album,
1461 BT_META_DATA_MAX_LEN))
1462 BT_ERR("Error in copying Album\n");
1463 if (_bt_copy_utf8_string(meta_data.genre, metadata.genre,
1464 BT_META_DATA_MAX_LEN))
1465 BT_ERR("Error in copying Genre\n");
1467 if (_bt_utf8_validate(meta_data.title) == FALSE)
1468 meta_data.title[0] = '\0';
1470 if (_bt_utf8_validate(meta_data.artist) == FALSE)
1471 meta_data.artist[0] = '\0';
1473 if (_bt_utf8_validate(meta_data.album) == FALSE)
1474 meta_data.album[0] = '\0';
1476 if (_bt_utf8_validate(meta_data.genre) == FALSE)
1477 meta_data.genre[0] = '\0';
1479 meta_data.total_tracks = metadata.total_tracks;
1480 meta_data.number = metadata.number;
1481 meta_data.duration = metadata.duration;
1483 g_free((gpointer)metadata.title);
1484 g_free((gpointer)metadata.artist);
1485 g_free((gpointer)metadata.album);
1486 g_free((gpointer)metadata.genre);
1488 g_array_append_vals(*out_param1, &meta_data,
1489 sizeof(media_metadata_t));
1492 case BT_RFCOMM_CLIENT_CONNECT: {
1493 #ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
1494 result = BLUETOOTH_ERROR_NONE;
1496 bluetooth_device_address_t address = { {0} };
1500 __bt_service_get_parameters(in_param1,
1501 &address, sizeof(bluetooth_device_address_t));
1503 input_string = &g_array_index(in_param2, char, 0);
1505 connect_type = g_array_index(in_param3, int, 0);
1507 if (connect_type == BT_RFCOMM_UUID) {
1508 result = _bt_rfcomm_connect_using_uuid(request_id,
1509 &address, input_string);
1511 result = _bt_rfcomm_connect_using_channel(request_id,
1512 &address, input_string);
1515 if (result != BLUETOOTH_ERROR_NONE) {
1516 g_array_append_vals(*out_param1, &address,
1517 sizeof(bluetooth_device_address_t));
1522 case BT_RFCOMM_CLIENT_CANCEL_CONNECT:
1523 result = _bt_rfcomm_cancel_connect();
1525 case BT_RFCOMM_CLIENT_IS_CONNECTED: {
1526 gboolean connected = FALSE;
1527 result = _bt_rfcomm_is_connected(&connected);
1529 g_array_append_vals(*out_param1, &connected, sizeof(gboolean));
1532 case BT_RFCOMM_SOCKET_DISCONNECT: {
1533 #ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
1534 result = BLUETOOTH_ERROR_NONE;
1538 socket_fd = g_array_index(in_param1, int, 0);
1540 result = _bt_rfcomm_disconnect(socket_fd);
1544 case BT_RFCOMM_SOCKET_WRITE: {
1545 #ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
1546 result = BLUETOOTH_ERROR_NONE;
1552 socket_fd = g_array_index(in_param1, int, 0);
1553 length = g_array_index(in_param2, int, 0);
1554 buffer = &g_array_index(in_param3, char, 0);
1556 result = _bt_rfcomm_write(socket_fd, buffer, length);
1560 case BT_RFCOMM_CREATE_SOCKET: {
1561 #ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
1562 result = BLUETOOTH_ERROR_NONE;
1568 sender = (char *)g_dbus_method_invocation_get_sender(context);
1569 uuid = &g_array_index(in_param1, char, 0);
1571 result = _bt_rfcomm_create_socket(sender, uuid);
1575 result = BLUETOOTH_ERROR_NONE;
1578 g_array_append_vals(*out_param1, &socket_fd, sizeof(int));
1584 case BT_RFCOMM_REMOVE_SOCKET: {
1585 #ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
1586 result = BLUETOOTH_ERROR_NONE;
1590 socket_fd = g_array_index(in_param1, int, 0);
1592 result = _bt_rfcomm_remove_socket(socket_fd);
1596 case BT_RFCOMM_LISTEN: {
1601 __bt_service_get_parameters(in_param1, &socket_fd,
1603 __bt_service_get_parameters(in_param2, &pending,
1605 __bt_service_get_parameters(in_param3, &is_native,
1608 result = _bt_rfcomm_listen(socket_fd, pending, is_native);
1611 case BT_RFCOMM_IS_UUID_AVAILABLE: {
1612 gboolean available = TRUE;
1615 uuid = (char *)g_variant_get_data(in_param1);
1617 result = _bt_rfcomm_is_uuid_available(uuid, &available);
1619 g_array_append_vals(*out_param1, &available, sizeof(gboolean));
1622 case BT_RFCOMM_ACCEPT_CONNECTION: {
1625 __bt_service_get_parameters(in_param1, &socket_fd, sizeof(int));
1626 BT_DBG(" socket fd %d", socket_fd);
1627 result = _bt_rfcomm_accept_connection();
1630 case BT_RFCOMM_REJECT_CONNECTION: {
1633 __bt_service_get_parameters(in_param1, &socket_fd, sizeof(int));
1634 BT_DBG(" socket fd %d", socket_fd);
1635 result = _bt_rfcomm_reject_connection();
1638 case BT_RFCOMM_CREATE_SOCKET_EX: {
1639 result = BLUETOOTH_ERROR_NONE;
1642 case BT_RFCOMM_REMOVE_SOCKET_EX: {
1643 result = BLUETOOTH_ERROR_NONE;
1646 case BT_CONNECT_LE: {
1647 bluetooth_device_address_t address = { {0} };
1648 gboolean auto_connect;
1650 __bt_service_get_parameters(in_param1,
1651 &address, sizeof(bluetooth_device_address_t));
1652 __bt_service_get_parameters(in_param2,
1653 &auto_connect, sizeof(gboolean));
1655 result = _bt_connect_le_device(request_id, &address,
1657 if (result != BLUETOOTH_ERROR_NONE) {
1658 g_array_append_vals(*out_param1, &address,
1659 sizeof(bluetooth_device_address_t));
1664 case BT_DISCONNECT_LE: {
1665 bluetooth_device_address_t address = { {0} };
1667 __bt_service_get_parameters(in_param1, &address,
1668 sizeof(bluetooth_device_address_t));
1670 result = _bt_disconnect_le_device(request_id, &address);
1671 if (result != BLUETOOTH_ERROR_NONE) {
1672 g_array_append_vals(*out_param1, &address,
1673 sizeof(bluetooth_device_address_t));
1678 case BT_SET_LE_PRIVACY: {
1679 gboolean set_privacy;
1681 __bt_service_get_parameters(in_param1, &set_privacy,
1684 result = _bt_set_le_privacy(set_privacy);
1688 case BT_REQ_ATT_MTU: {
1689 bluetooth_device_address_t address = { {0} };
1692 __bt_service_get_parameters(in_param1,
1693 &address, sizeof(bluetooth_device_address_t));
1694 __bt_service_get_parameters(in_param2,
1695 &mtu, sizeof(unsigned int));
1697 result = _bt_request_att_mtu(request_id, &address, mtu);
1698 if (result != BLUETOOTH_ERROR_NONE) {
1699 g_array_append_vals(*out_param1, &address,
1700 sizeof(bluetooth_device_info_t));
1704 case BT_GET_ATT_MTU: {
1705 bluetooth_device_address_t address = { {0} };
1706 unsigned int mtu = 0;
1708 __bt_service_get_parameters(in_param1,
1709 &address, sizeof(bluetooth_device_address_t));
1711 result = _bt_get_att_mtu(&address, &mtu);
1712 BT_DBG("MTU: %d", mtu);
1713 if (result == BLUETOOTH_ERROR_NONE) {
1714 g_array_append_vals(*out_param1, &mtu,
1715 sizeof(unsigned int));
1719 case BT_GET_DEVICE_IDA: {
1720 bluetooth_device_address_t address = { {0} };
1721 bluetooth_device_address_t id_addr = { {0} };
1723 __bt_service_get_parameters(in_param1,
1724 &address, sizeof(bluetooth_device_address_t));
1726 result = _bt_get_device_ida(&address, &id_addr);
1728 if (result == BLUETOOTH_ERROR_NONE) {
1729 g_array_append_vals(*out_param1, &id_addr,
1730 sizeof(bluetooth_device_address_t));
1734 case BT_SET_LE_STATIC_RANDOM_ADDRESS: {
1737 __bt_service_get_parameters(in_param1, &is_enable,
1740 result = _bt_set_le_static_random_address(is_enable);
1744 case BT_HDP_CONNECT:
1745 case BT_HDP_DISCONNECT:
1746 case BT_HDP_SEND_DATA:
1748 case BT_GATT_GET_PRIMARY_SERVICES:
1749 case BT_GATT_DISCOVER_CHARACTERISTICS:
1750 case BT_GATT_SET_PROPERTY_REQUEST:
1751 case BT_GATT_READ_CHARACTERISTIC:
1752 case BT_GATT_DISCOVER_CHARACTERISTICS_DESCRIPTOR:
1754 case BT_HID_DEVICE_ACTIVATE:
1755 case BT_HID_DEVICE_DEACTIVATE:
1756 case BT_HID_DEVICE_CONNECT:
1757 case BT_HID_DEVICE_DISCONNECT:
1758 case BT_HID_DEVICE_SEND_MOUSE_EVENT:
1759 case BT_HID_DEVICE_SEND_KEY_EVENT:
1760 case BT_HID_DEVICE_SEND_REPLY_TO_REPORT:
1761 /* Just call to check the privilege */
1763 #ifndef GATT_NO_RELAY
1764 case BT_GATT_WATCH_CHARACTERISTIC: {
1765 char *sender = NULL;
1767 sender = (char *)g_dbus_method_invocation_get_sender(context);
1769 result = _bt_insert_gatt_client_sender(sender);
1773 case BT_GATT_UNWATCH_CHARACTERISTIC: {
1774 char *sender = NULL;
1776 sender = (char *)g_dbus_method_invocation_get_sender(context);
1778 result = _bt_delete_gatt_client_sender(sender);
1783 case BT_LE_IPSP_INIT:
1784 result = _bt_initialize_ipsp();
1786 case BT_LE_IPSP_DEINIT:
1787 result = _bt_deinitialize_ipsp();
1789 case BT_LE_IPSP_CONNECT: {
1790 bluetooth_device_address_t address = { {0} };
1791 __bt_service_get_parameters(in_param1, &address,
1792 sizeof(bluetooth_device_address_t));
1794 result = _bt_connect_le_ipsp_device(&address);
1797 case BT_LE_IPSP_DISCONNECT: {
1798 bluetooth_device_address_t address = { {0} };
1800 __bt_service_get_parameters(in_param1, &address,
1801 sizeof(bluetooth_device_address_t));
1803 result = _bt_disconnect_le_ipsp_device(&address);
1806 case BT_LE_READ_MAXIMUM_DATA_LENGTH: {
1807 bluetooth_le_read_maximum_data_length_t max_le_datalength = {0};
1809 result = _bt_le_read_maximum_data_length(&max_le_datalength);
1811 g_array_append_vals(*out_param1, &max_le_datalength,
1812 sizeof(bluetooth_le_read_maximum_data_length_t));
1815 case BT_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH: {
1816 unsigned int def_tx_Octects = 0;
1817 unsigned int def_tx_Time = 0;
1819 __bt_service_get_parameters(in_param1,
1820 &def_tx_Octects, sizeof(int));
1821 __bt_service_get_parameters(in_param2,
1822 &def_tx_Time, sizeof(int));
1824 result = _bt_le_write_host_suggested_default_data_length(
1825 def_tx_Octects, def_tx_Time);
1828 case BT_LE_READ_HOST_SUGGESTED_DATA_LENGTH: {
1829 bluetooth_le_read_host_suggested_data_length_t def_data_length = {0};
1831 result = _bt_le_read_host_suggested_default_data_length(&def_data_length);
1833 g_array_append_vals(*out_param1, &def_data_length,
1834 sizeof(bluetooth_le_read_host_suggested_data_length_t));
1838 case BT_LE_SET_DATA_LENGTH: {
1839 int max_tx_Octets = 0;
1840 int max_tx_Time = 0;
1841 bluetooth_device_address_t address = { {0} };
1843 __bt_service_get_parameters(in_param1, &address,
1844 sizeof(bluetooth_device_address_t));
1845 __bt_service_get_parameters(in_param2,
1846 &max_tx_Octets, sizeof(int));
1847 __bt_service_get_parameters(in_param3,
1848 &max_tx_Time, sizeof(int));
1850 result = _bt_le_set_data_length(&address, max_tx_Octets, max_tx_Time);
1853 case BT_DPM_SET_ALLOW_BT_MODE: {
1854 dpm_bt_allow_t value = DPM_BT_ERROR;
1856 __bt_service_get_parameters(in_param1, &value,
1859 result = _bt_dpm_set_allow_bluetooth_mode(value);
1862 case BT_DPM_GET_ALLOW_BT_MODE: {
1863 dpm_bt_allow_t value = DPM_BT_ERROR;
1865 value = _bt_dpm_get_allow_bluetooth_mode();
1866 result = DPM_RESULT_SUCCESS;
1867 g_array_append_vals(*out_param1, &value, sizeof(int));
1871 case BT_DPM_SET_DEVICE_RESTRITION: {
1872 dpm_status_t value = DPM_BT_ERROR;
1874 __bt_service_get_parameters(in_param1, &value,
1877 result = _bt_dpm_activate_bluetooth_device_restriction(value);
1880 case BT_DPM_GET_DEVICE_RESTRITION: {
1881 dpm_status_t value = DPM_BT_ERROR;
1883 value = _bt_dpm_is_bluetooth_device_restriction_active();
1884 result = DPM_RESULT_SUCCESS;
1885 g_array_append_vals(*out_param1, &value, sizeof(int));
1889 case BT_DPM_SET_UUID_RESTRITION: {
1890 dpm_status_t value = DPM_BT_ERROR;
1892 __bt_service_get_parameters(in_param1, &value,
1895 result = _bt_dpm_activate_bluetoooth_uuid_restriction(value);
1898 case BT_DPM_GET_UUID_RESTRITION: {
1899 dpm_status_t value = DPM_BT_ERROR;
1901 value = _bt_dpm_is_bluetooth_uuid_restriction_active();
1902 result = DPM_RESULT_SUCCESS;
1903 g_array_append_vals(*out_param1, &value, sizeof(int));
1907 case BT_DPM_ADD_DEVICES_BLACKLIST: {
1908 bluetooth_device_address_t address = { {0} };
1910 __bt_service_get_parameters(in_param1, &address,
1911 sizeof(bluetooth_device_address_t));
1913 result = _bt_dpm_add_bluetooth_devices_to_blacklist(&address);
1916 case BT_DPM_ADD_DEVICES_WHITELIST: {
1917 bluetooth_device_address_t address = { {0} };
1919 __bt_service_get_parameters(in_param1, &address,
1920 sizeof(bluetooth_device_address_t));
1922 result = _bt_dpm_add_bluetooth_devices_to_whitelist(&address);
1925 case BT_DPM_ADD_UUIDS_BLACKLIST: {
1926 const char *uuid = NULL;
1928 uuid = g_variant_get_data(in_param1);
1930 result = _bt_dpm_add_bluetooth_uuids_to_blacklist(uuid);
1933 case BT_DPM_ADD_UUIDS_WHITELIST: {
1934 const char *uuid = NULL;
1936 uuid = g_variant_get_data(in_param1);
1938 result = _bt_dpm_add_bluetooth_uuids_to_whitelist(uuid);
1941 case BT_DPM_CLEAR_DEVICES_BLACKLIST: {
1942 result = _bt_dpm_clear_bluetooth_devices_from_blacklist();
1945 case BT_DPM_CLEAR_DEVICES_WHITELIST: {
1946 result = _bt_dpm_clear_bluetooth_devices_from_whitelist();
1949 case BT_DPM_CLEAR_UUIDS_BLACKLIST: {
1950 result = _bt_dpm_clear_bluetooth_uuids_from_blacklist();
1953 case BT_DPM_CLEAR_UUIDS_WHITELIST: {
1954 result = _bt_dpm_clear_bluetooth_uuids_from_whitelist();
1957 case BT_DPM_REMOVE_DEVICE_BLACKLIST: {
1958 bluetooth_device_address_t address = { {0} };
1960 __bt_service_get_parameters(in_param1, &address,
1961 sizeof(bluetooth_device_address_t));
1963 result = _bt_dpm_remove_bluetooth_devices_from_blacklist(&address);
1966 case BT_DPM_REMOVE_DEVICE_WHITELIST: {
1967 bluetooth_device_address_t address = { {0} };
1969 __bt_service_get_parameters(in_param1, &address,
1970 sizeof(bluetooth_device_address_t));
1972 result = _bt_dpm_remove_bluetooth_devices_from_whitelist(&address);
1975 case BT_DPM_REMOVE_UUID_BLACKLIST: {
1976 const char *uuid = NULL;
1978 uuid = g_variant_get_data(in_param1);
1980 result = _bt_dpm_remove_bluetooth_uuids_from_blacklist(uuid);
1983 case BT_DPM_REMOVE_UUID_WHITELIST: {
1984 const char *uuid = NULL;
1986 uuid = g_variant_get_data(in_param1);
1988 result = _bt_dpm_remove_bluetooth_uuids_from_whitelist(uuid);
1992 case BT_DPM_GET_DEVICES_BLACKLIST: {
1993 result = _bt_dpm_get_bluetooth_devices_from_blacklist(out_param1);
1996 case BT_DPM_GET_DEVICES_WHITELIST: {
1997 result = _bt_dpm_get_bluetooth_devices_from_whitelist(out_param1);
2000 case BT_DPM_GET_UUIDS_BLACKLIST: {
2001 result = _bt_dpm_get_bluetooth_uuids_from_blacklist(out_param1);
2004 case BT_DPM_GET_UUIDS_WHITELIST: {
2005 result = _bt_dpm_get_bluetooth_uuids_from_whitelist(out_param1);
2008 case BT_DPM_SET_ALLOW_OUTGOING_CALL: {
2009 dpm_status_t value = DPM_BT_ERROR;
2011 __bt_service_get_parameters(in_param1, &value,
2014 result = _bt_dpm_set_allow_bluetooth_outgoing_call(value);
2018 case BT_DPM_GET_ALLOW_OUTGOING_CALL: {
2019 dpm_status_t value = DPM_BT_ERROR;
2021 value = _bt_dpm_get_allow_bluetooth_outgoing_call();
2022 result = DPM_RESULT_SUCCESS;
2023 g_array_append_vals(*out_param1, &value, sizeof(int));
2027 case BT_DPM_SET_PAIRING_STATE: {
2028 dpm_status_t value = DPM_BT_ERROR;
2030 __bt_service_get_parameters(in_param1, &value,
2033 result = _bt_dpm_set_bluetooth_pairing_state(value);
2037 case BT_DPM_GET_PAIRING_STATE: {
2038 dpm_status_t value = DPM_BT_ERROR;
2040 value = _bt_dpm_get_bluetooth_pairing_state();
2041 result = DPM_RESULT_SUCCESS;
2042 g_array_append_vals(*out_param1, &value, sizeof(int));
2046 case BT_DPM_SET_PROFILE_STATE: {
2047 dpm_status_t value = DPM_BT_ERROR;
2048 dpm_profile_t profile = DPM_PROFILE_NONE;
2050 __bt_service_get_parameters(in_param1, &profile,
2052 __bt_service_get_parameters(in_param2, &value,
2055 result = _bt_dpm_set_bluetooth_profile_state(profile, value);
2059 case BT_DPM_GET_PROFILE_STATE: {
2060 dpm_status_t value = DPM_BT_ERROR;
2061 dpm_profile_t profile = DPM_PROFILE_NONE;
2063 __bt_service_get_parameters(in_param2, &profile,
2066 value = _bt_dpm_get_bluetooth_profile_state(profile);
2067 result = DPM_RESULT_SUCCESS;
2068 g_array_append_vals(*out_param1, &value, sizeof(int));
2072 case BT_DPM_SET_DESKROP_CONNECTIVITY_STATE: {
2073 dpm_status_t value = DPM_BT_ERROR;
2075 __bt_service_get_parameters(in_param1, &value,
2078 result = _bt_dpm_set_bluetooth_desktop_connectivity_state(value);
2082 case BT_DPM_GET_DESKROP_CONNECTIVITY_STATE: {
2083 dpm_status_t value = DPM_BT_ERROR;
2085 value = _bt_dpm_get_bluetooth_desktop_connectivity_state();
2086 result = DPM_RESULT_SUCCESS;
2087 g_array_append_vals(*out_param1, &value, sizeof(int));
2091 case BT_DPM_SET_DISCOVERABLE_STATE: {
2092 dpm_status_t value = DPM_BT_ERROR;
2094 __bt_service_get_parameters(in_param1, &value,
2097 result = _bt_dpm_set_bluetooth_discoverable_state(value);
2101 case BT_DPM_GET_DISCOVERABLE_STATE: {
2102 dpm_status_t value = DPM_BT_ERROR;
2104 value = _bt_dpm_get_bluetooth_discoverable_state();
2105 result = DPM_RESULT_SUCCESS;
2106 g_array_append_vals(*out_param1, &value, sizeof(int));
2110 case BT_DPM_SET_LIMITED_DISCOVERABLE_STATE: {
2111 dpm_status_t value = DPM_BT_ERROR;
2113 __bt_service_get_parameters(in_param1, &value,
2116 result = _bt_dpm_set_bluetooth_limited_discoverable_state(value);
2120 case BT_DPM_GET_LIMITED_DISCOVERABLE_STATE: {
2121 dpm_status_t value = DPM_BT_ERROR;
2123 value = _bt_dpm_get_bluetooth_limited_discoverable_state();
2124 result = DPM_RESULT_SUCCESS;
2125 g_array_append_vals(*out_param1, &value, sizeof(int));
2129 case BT_DPM_SET_DATA_TRANSFER_STATE: {
2130 dpm_status_t value = DPM_BT_ERROR;
2132 __bt_service_get_parameters(in_param1, &value,
2135 result = _bt_dpm_set_bluetooth_data_transfer_state(value);
2139 case BT_DPM_GET_DATA_TRANSFER_STATE: {
2140 dpm_status_t value = DPM_BT_ERROR;
2142 value = _bt_dpm_get_allow_bluetooth_data_transfer_state();
2143 result = DPM_RESULT_SUCCESS;
2144 g_array_append_vals(*out_param1, &value, sizeof(int));
2148 case BT_PXP_SET_PROPERTY: {
2149 bluetooth_device_address_t address = { {0} };
2150 unsigned int property = 0;
2151 unsigned int value = 0;
2153 __bt_service_get_parameters(in_param1,
2154 &address, sizeof(bluetooth_device_address_t));
2155 __bt_service_get_parameters(in_param2,
2156 &property, sizeof(int));
2157 __bt_service_get_parameters(in_param3,
2158 &value, sizeof(int));
2160 result = bt_set_proximity_property(&address, property, value);
2163 case BT_PXP_GET_PROPERTY: {
2164 bluetooth_device_address_t address = { {0} };
2165 unsigned int property = 0;
2168 __bt_service_get_parameters(in_param1,
2169 &address, sizeof(bluetooth_device_address_t));
2170 __bt_service_get_parameters(in_param2,
2171 &property, sizeof(unsigned int));
2173 result = bt_get_proximity_property(&address, property, &value);
2174 if (result == BLUETOOTH_ERROR_NONE) {
2175 g_array_append_vals(*out_param1, &value,
2180 case BT_PXP_GET_SUPPORTED_SERIVCES: {
2181 bluetooth_device_address_t address = { {0} };
2182 unsigned int property = 0;
2184 __bt_service_get_parameters(in_param1,
2185 &address, sizeof(bluetooth_device_address_t));
2187 result = bt_get_proximity_supported_services(&address, &property);
2188 if (result == BLUETOOTH_ERROR_NONE) {
2189 g_array_append_vals(*out_param1, &property,
2194 case BT_PXP_REGISTER_REPORTER: {
2195 result = bt_register_proximity_reporter();
2198 case BT_PXP_UNREGISTER_REPORTER: {
2199 result = bt_unregister_proximity_reporter();
2203 result = BLUETOOTH_ERROR_INTERNAL;
2210 int __bt_obexd_request(int function_name,
2213 GDBusMethodInvocation *context,
2214 GVariant *in_param1,
2215 GVariant *in_param2,
2216 GVariant *in_param3,
2217 GVariant *in_param4,
2218 GArray **out_param1)
2224 BT_DBG("function_name : %x", function_name);
2226 switch (function_name) {
2227 case BT_OPP_PUSH_FILES: {
2228 BT_DBG("BT_OPP_PUSH_FILES");
2230 bluetooth_device_address_t address = { {0} };
2231 bt_file_path_t *path;
2236 __bt_service_get_parameters(in_param1, &address,
2237 sizeof(bluetooth_device_address_t));
2238 __bt_service_get_parameters(in_param3, &file_count,
2241 file_path = g_new0(char *, file_count + 1);
2243 param2 = g_array_new(TRUE, TRUE, sizeof(gchar));
2244 __bt_fill_garray_from_variant(in_param2, param2);
2246 for (i = 0; i < file_count; i++) {
2247 path = &g_array_index(param2, bt_file_path_t, i);
2248 file_path[i] = g_strdup(path->path);
2250 BT_DBG("_bt_opp_client_push_files");
2251 result = _bt_opp_client_push_files(request_id, context,
2252 &address, file_path,
2255 for (i = 0; i < file_count; i++)
2256 g_free(file_path[i]);
2259 g_array_free(param2, TRUE);
2263 case BT_OPP_CANCEL_PUSH: {
2264 result = _bt_opp_client_cancel_push();
2268 case BT_OPP_IS_PUSHING_FILES: {
2269 gboolean is_sending = FALSE;
2271 result = _bt_opp_client_is_sending(&is_sending);
2273 g_array_append_vals(*out_param1, &is_sending,
2277 case BT_OPP_GET_TRANSFER_PROGRESS: {
2280 guint8 progress = 0;
2282 __bt_service_get_parameters(in_param1, &direction,
2284 __bt_service_get_parameters(in_param2, &transfer_id,
2287 result = _bt_opp_get_client_progress(&progress);
2289 result = _bt_opp_get_server_progress(transfer_id, &progress);
2291 g_array_append_vals(*out_param1, &progress,
2296 case BT_OBEX_SERVER_ALLOCATE: {
2302 sender = (char *)g_dbus_method_invocation_get_sender(context);
2304 path = (char *)g_variant_get_data(in_param1);
2305 __bt_service_get_parameters(in_param2, &is_native,
2307 __bt_service_get_parameters(in_param3, &app_pid,
2310 result = _bt_obex_server_allocate(sender,
2311 path, app_pid, is_native);
2315 case BT_OBEX_SERVER_DEALLOCATE: {
2319 __bt_service_get_parameters(in_param1, &is_native,
2321 __bt_service_get_parameters(in_param2, &app_pid,
2324 result = _bt_obex_server_deallocate(app_pid, is_native);
2327 case BT_OBEX_SERVER_IS_ACTIVATED: {
2328 gboolean is_activated = FALSE;
2330 result = _bt_obex_server_is_activated(&is_activated);
2332 g_array_append_vals(*out_param1, &is_activated,
2337 case BT_OBEX_SERVER_ACCEPT_CONNECTION: {
2338 result = _bt_obex_server_accept_connection(request_id);
2342 case BT_OBEX_SERVER_REJECT_CONNECTION: {
2343 result = _bt_obex_server_reject_connection();
2347 case BT_OBEX_SERVER_ACCEPT_FILE: {
2350 file_name = (char *)g_variant_get_data(in_param1);
2352 result = _bt_obex_server_accept_authorize(file_name, TRUE);
2356 case BT_OBEX_SERVER_REJECT_FILE: {
2357 result = _bt_obex_server_reject_authorize();
2361 case BT_OBEX_SERVER_SET_PATH: {
2363 char *destination_path;
2365 destination_path = (char *)g_variant_get_data(in_param1);
2366 __bt_service_get_parameters(in_param2, &is_native,
2369 result = _bt_obex_server_set_destination_path(destination_path,
2374 case BT_OBEX_SERVER_SET_ROOT: {
2377 root = (char *)g_variant_get_data(in_param1);
2379 result = _bt_obex_server_set_root(root);
2383 case BT_OBEX_SERVER_CANCEL_TRANSFER: {
2386 __bt_service_get_parameters(in_param1, &transfer_id,
2389 result = _bt_obex_server_cancel_transfer(transfer_id);
2393 case BT_OBEX_SERVER_CANCEL_ALL_TRANSFERS: {
2394 result = _bt_obex_server_cancel_all_transfers();
2398 case BT_OBEX_SERVER_IS_RECEIVING: {
2399 gboolean is_receiving = FALSE;
2401 result = _bt_obex_server_is_receiving(&is_receiving);
2403 g_array_append_vals(*out_param1, &is_receiving,
2407 case BT_PBAP_CONNECT: {
2408 bluetooth_device_address_t address = { {0} };
2410 __bt_service_get_parameters(in_param1, &address,
2411 sizeof(bluetooth_device_address_t));
2413 result = _bt_pbap_connect(&address);
2416 case BT_PBAP_DISCONNECT: {
2417 bluetooth_device_address_t address = { {0} };
2419 __bt_service_get_parameters(in_param1, &address,
2420 sizeof(bluetooth_device_address_t));
2422 result = _bt_pbap_disconnect(&address);
2425 case BT_PBAP_GET_PHONEBOOK_SIZE: {
2426 bluetooth_device_address_t address = { {0} };
2427 bt_pbap_folder_t folder = { 0, };
2429 __bt_service_get_parameters(in_param1, &address,
2430 sizeof(bluetooth_device_address_t));
2431 __bt_service_get_parameters(in_param2, &folder,
2432 sizeof(bt_pbap_folder_t));
2434 result = _bt_pbap_get_phonebook_size(&address,
2435 folder.addressbook, folder.folder_type);
2438 case BT_PBAP_GET_PHONEBOOK: {
2439 bluetooth_device_address_t address = { {0} };
2440 bt_pbap_folder_t folder = { 0, };
2441 bt_pbap_pull_parameters_t app_param = { 0, };
2443 __bt_service_get_parameters(in_param1, &address,
2444 sizeof(bluetooth_device_address_t));
2445 __bt_service_get_parameters(in_param2, &folder,
2446 sizeof(bt_pbap_folder_t));
2447 __bt_service_get_parameters(in_param3, &app_param,
2448 sizeof(bt_pbap_pull_parameters_t));
2450 result = _bt_pbap_get_phonebook(&address, folder.addressbook,
2451 folder.folder_type, &app_param);
2454 case BT_PBAP_GET_LIST: {
2455 bluetooth_device_address_t address = { {0} };
2456 bt_pbap_folder_t folder = { 0, };
2457 bt_pbap_list_parameters_t app_param = { 0, };
2459 __bt_service_get_parameters(in_param1, &address,
2460 sizeof(bluetooth_device_address_t));
2461 __bt_service_get_parameters(in_param2, &folder,
2462 sizeof(bt_pbap_folder_t));
2463 __bt_service_get_parameters(in_param3, &app_param,
2464 sizeof(bt_pbap_list_parameters_t));
2466 result = _bt_pbap_get_list(&address, folder.addressbook,
2467 folder.folder_type, &app_param);
2470 case BT_PBAP_PULL_VCARD: {
2471 bluetooth_device_address_t address = { {0} };
2472 bt_pbap_folder_t folder = { 0, };
2473 bt_pbap_pull_vcard_parameters_t app_param = { 0, };
2475 __bt_service_get_parameters(in_param1, &address,
2476 sizeof(bluetooth_device_address_t));
2477 __bt_service_get_parameters(in_param2, &folder,
2478 sizeof(bt_pbap_folder_t));
2479 __bt_service_get_parameters(in_param3, &app_param,
2480 sizeof(bt_pbap_pull_vcard_parameters_t));
2482 result = _bt_pbap_pull_vcard(&address, folder.addressbook,
2483 folder.folder_type, &app_param);
2486 case BT_PBAP_PHONEBOOK_SEARCH: {
2487 bluetooth_device_address_t address = { {0} };
2488 bt_pbap_folder_t folder = { 0, };
2489 bt_pbap_search_parameters_t app_param = { 0, };
2491 __bt_service_get_parameters(in_param1, &address,
2492 sizeof(bluetooth_device_address_t));
2493 __bt_service_get_parameters(in_param2, &folder,
2494 sizeof(bt_pbap_folder_t));
2495 __bt_service_get_parameters(in_param3, &app_param,
2496 sizeof(bt_pbap_search_parameters_t));
2498 result = _bt_pbap_phonebook_search(&address, folder.addressbook,
2499 folder.folder_type, &app_param);
2504 BT_ERR("Unknown function!");
2505 result = BLUETOOTH_ERROR_INTERNAL;
2514 int __bt_agent_request(int function_name,
2517 GDBusMethodInvocation *context,
2518 GVariant *in_param1,
2519 GVariant *in_param2,
2520 GVariant *in_param3,
2521 GVariant *in_param4,
2522 GArray **out_param1)
2525 switch (function_name) {
2526 case BT_SET_AUTHORIZATION: {
2532 __bt_service_get_parameters(in_param1, &type, sizeof(int));
2533 uuid = (char *)g_variant_get_data(in_param2);
2534 path = (char *)g_variant_get_data(in_param3);
2535 __bt_service_get_parameters(in_param4, &fd, sizeof(int));
2537 result = _bt_register_osp_server_in_agent(type, uuid, path, fd);
2540 case BT_UNSET_AUTHORIZATION: {
2544 __bt_service_get_parameters(in_param1, &type, sizeof(int));
2545 uuid = (char *)g_variant_get_data(in_param2);
2547 result = _bt_unregister_osp_server_in_agent(type, uuid);
2551 BT_ERR("Unknown function!");
2552 result = BLUETOOTH_ERROR_INTERNAL;
2559 int __bt_core_request(int function_name,
2562 GDBusMethodInvocation *context,
2563 GVariant *in_param1)
2567 switch (function_name) {
2568 case BT_ENABLE_ADAPTER:
2572 status = _bt_adapter_get_status();
2574 if (status == BT_ACTIVATING) {
2575 BT_DBG("Enabling in progress");
2576 result = BLUETOOTH_ERROR_IN_PROGRESS;
2577 } else if (status == BT_ACTIVATED) {
2578 BT_DBG("Already enabled");
2579 result = BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED;
2581 _bt_adapter_set_status(BT_ACTIVATING);
2582 _bt_adapter_start_enable_timer();
2583 result = BLUETOOTH_ERROR_NONE;
2588 case BT_DISABLE_ADAPTER:
2592 status = _bt_adapter_get_status();
2593 if (status == BT_DEACTIVATING) {
2594 BT_DBG("Disabling in progress");
2595 result = BLUETOOTH_ERROR_IN_PROGRESS;
2596 } else if (status == BT_DEACTIVATED) {
2597 BT_DBG("Already disabled");
2598 result = BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
2600 _bt_adapter_set_status(BT_DEACTIVATING);
2601 result = BLUETOOTH_ERROR_NONE;
2606 case BT_ENABLE_ADAPTER_LE:
2608 bt_le_status_t le_status;
2610 le_status = _bt_adapter_get_le_status();
2611 if (le_status == BT_LE_ACTIVATING) {
2612 BT_DBG("Enabling in progress");
2613 result = BLUETOOTH_ERROR_IN_PROGRESS;
2614 } else if (le_status == BT_LE_ACTIVATED) {
2615 BT_DBG("Already enabled");
2616 result = BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED;
2618 _bt_adapter_set_le_status(BT_LE_ACTIVATING);
2619 _bt_adapter_start_le_enable_timer();
2620 result = BLUETOOTH_ERROR_NONE;
2625 case BT_DISABLE_ADAPTER_LE:
2627 bt_le_status_t le_status;
2629 le_status = _bt_adapter_get_le_status();
2630 if (le_status == BT_LE_DEACTIVATING) {
2631 BT_DBG("Disabling in progress");
2632 result = BLUETOOTH_ERROR_IN_PROGRESS;
2633 } else if (le_status == BT_LE_DEACTIVATED) {
2634 BT_DBG("Already disabled");
2635 result = BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
2637 _bt_adapter_set_le_status(BT_LE_DEACTIVATING);
2638 result = BLUETOOTH_ERROR_NONE;
2644 BT_ERR("Unknown function!");
2645 result = BLUETOOTH_ERROR_INTERNAL;
2652 gboolean __bt_service_check_privilege(int function_name,
2654 const char *unique_name)
2657 gboolean result = TRUE;
2658 char *client_creds = NULL;
2659 char *user_creds = NULL;
2660 char *client_session = "";
2661 enum cynara_client_creds client_creds_method = CLIENT_METHOD_SMACK;
2662 enum cynara_user_creds user_creds_method = USER_METHOD_UID;
2663 char err_msg[256] = {0, };
2665 retv_if(unique_name == NULL, FALSE);
2666 retv_if(bt_service_conn == NULL, FALSE);
2668 ret_val = cynara_creds_get_default_client_method(&client_creds_method);
2669 if (ret_val != CYNARA_API_SUCCESS) {
2670 cynara_strerror(ret_val, err_msg, sizeof(err_msg));
2671 BT_ERR("Fail to get default client method: %s", err_msg);
2675 ret_val = cynara_creds_get_default_user_method(&user_creds_method);
2676 if (ret_val != CYNARA_API_SUCCESS) {
2677 cynara_strerror(ret_val, err_msg, sizeof(err_msg));
2678 BT_ERR("Fail to get default user method: %s", err_msg);
2682 ret_val = cynara_creds_gdbus_get_client(bt_service_conn, unique_name, client_creds_method, &client_creds);
2683 if (ret_val != CYNARA_API_SUCCESS) {
2684 cynara_strerror(ret_val, err_msg, sizeof(err_msg));
2685 BT_ERR("Fail to get client credential: %s", err_msg);
2689 ret_val = cynara_creds_gdbus_get_user(bt_service_conn, unique_name, user_creds_method, &user_creds);
2690 if (ret_val != CYNARA_API_SUCCESS) {
2691 cynara_strerror(ret_val, err_msg, sizeof(err_msg));
2692 BT_ERR("Fail to get user credential: %s", err_msg);
2698 BT_DBG("%s, %s, %s", unique_name, client_creds, user_creds);
2700 switch (function_name) {
2701 case BT_SET_LOCAL_NAME:
2702 case BT_START_DISCOVERY:
2703 case BT_START_CUSTOM_DISCOVERY:
2704 case BT_CANCEL_DISCOVERY:
2705 case BT_OOB_ADD_REMOTE_DATA:
2706 case BT_OOB_REMOVE_REMOTE_DATA:
2707 case BT_SET_ADVERTISING:
2708 case BT_SET_CUSTOM_ADVERTISING:
2709 case BT_SET_ADVERTISING_PARAMETERS:
2710 case BT_START_LE_DISCOVERY:
2711 case BT_STOP_LE_DISCOVERY:
2712 case BT_SET_SCAN_PARAMETERS:
2713 case BT_SET_SCAN_TYPE:
2715 case BT_BOND_DEVICE:
2716 case BT_CANCEL_BONDING:
2717 case BT_UNBOND_DEVICE:
2719 case BT_SET_AUTHORIZATION:
2720 case BT_UNSET_AUTHORIZATION:
2721 case BT_SEARCH_SERVICE:
2723 case BT_RFCOMM_CLIENT_CONNECT:
2724 case BT_RFCOMM_CLIENT_CANCEL_CONNECT:
2725 case BT_RFCOMM_SOCKET_DISCONNECT:
2726 case BT_RFCOMM_SOCKET_WRITE:
2727 case BT_RFCOMM_CREATE_SOCKET:
2728 case BT_RFCOMM_REMOVE_SOCKET:
2730 case BT_OPP_PUSH_FILES:
2731 case BT_OPP_CANCEL_PUSH:
2733 case BT_OBEX_SERVER_ACCEPT_CONNECTION:
2734 case BT_OBEX_SERVER_REJECT_CONNECTION:
2735 case BT_OBEX_SERVER_ACCEPT_FILE:
2736 case BT_OBEX_SERVER_REJECT_FILE:
2737 case BT_OBEX_SERVER_SET_PATH:
2738 case BT_OBEX_SERVER_SET_ROOT:
2739 case BT_OBEX_SERVER_CANCEL_TRANSFER:
2740 case BT_OBEX_SERVER_CANCEL_ALL_TRANSFERS:
2742 case BT_AUDIO_CONNECT:
2743 case BT_AUDIO_DISCONNECT:
2745 case BT_AG_DISCONNECT:
2747 case BT_AV_DISCONNECT:
2748 case BT_AV_SOURCE_CONNECT:
2749 case BT_AV_SOURCE_DISCONNECT:
2750 case BT_AVRCP_CONTROL_CONNECT:
2751 case BT_AVRCP_CONTROL_DISCONNECT:
2752 case BT_AVRCP_HANDLE_CONTROL:
2753 case BT_AVRCP_SET_TRACK_INFO:
2754 case BT_AVRCP_SET_PROPERTY:
2755 case BT_AVRCP_SET_PROPERTIES:
2756 case BT_AVRCP_CONTROL_SET_PROPERTY:
2759 case BT_HF_DISCONNECT:
2761 case BT_HID_CONNECT:
2762 case BT_HID_DISCONNECT:
2764 case BT_HID_DEVICE_ACTIVATE:
2765 case BT_HID_DEVICE_DEACTIVATE:
2766 case BT_HID_DEVICE_CONNECT:
2767 case BT_HID_DEVICE_DISCONNECT:
2768 case BT_HID_DEVICE_SEND_MOUSE_EVENT:
2769 case BT_HID_DEVICE_SEND_KEY_EVENT:
2770 case BT_HID_DEVICE_SEND_REPLY_TO_REPORT:
2771 case BT_HID_DEVICE_SEND_CUSTOM_EVENT:
2774 case BT_DISCONNECT_LE:
2776 case BT_SET_ADVERTISING_DATA:
2777 case BT_SET_SCAN_RESPONSE_DATA:
2779 case BT_HDP_CONNECT:
2780 case BT_HDP_DISCONNECT:
2781 case BT_HDP_SEND_DATA:
2782 case BT_HDP_REGISTER_SINK_APP:
2783 case BT_HDP_UNREGISTER_SINK_APP:
2785 case BT_DPM_SET_ALLOW_BT_MODE:
2786 case BT_DPM_GET_ALLOW_BT_MODE:
2787 case BT_DPM_SET_DEVICE_RESTRITION:
2788 case BT_DPM_GET_DEVICE_RESTRITION:
2789 case BT_DPM_SET_UUID_RESTRITION:
2790 case BT_DPM_GET_UUID_RESTRITION:
2791 case BT_DPM_ADD_DEVICES_BLACKLIST:
2792 case BT_DPM_ADD_DEVICES_WHITELIST:
2793 case BT_DPM_ADD_UUIDS_BLACKLIST:
2794 case BT_DPM_ADD_UUIDS_WHITELIST:
2795 case BT_DPM_CLEAR_DEVICES_BLACKLIST:
2796 case BT_DPM_CLEAR_DEVICES_WHITELIST:
2797 case BT_DPM_CLEAR_UUIDS_BLACKLIST:
2798 case BT_DPM_CLEAR_UUIDS_WHITELIST:
2799 case BT_DPM_REMOVE_DEVICE_BLACKLIST:
2800 case BT_DPM_REMOVE_DEVICE_WHITELIST:
2801 case BT_DPM_REMOVE_UUID_BLACKLIST:
2802 case BT_DPM_REMOVE_UUID_WHITELIST:
2803 case BT_DPM_GET_DEVICES_BLACKLIST:
2804 case BT_DPM_GET_DEVICES_WHITELIST:
2805 case BT_DPM_GET_UUIDS_BLACKLIST:
2806 case BT_DPM_GET_UUIDS_WHITELIST:
2807 case BT_DPM_SET_ALLOW_OUTGOING_CALL:
2808 case BT_DPM_GET_ALLOW_OUTGOING_CALL:
2809 case BT_DPM_SET_PAIRING_STATE:
2810 case BT_DPM_GET_PAIRING_STATE:
2811 case BT_DPM_SET_PROFILE_STATE:
2812 case BT_DPM_GET_PROFILE_STATE:
2813 case BT_DPM_SET_DESKROP_CONNECTIVITY_STATE:
2814 case BT_DPM_GET_DESKROP_CONNECTIVITY_STATE:
2815 case BT_DPM_SET_DISCOVERABLE_STATE:
2816 case BT_DPM_GET_DISCOVERABLE_STATE:
2817 case BT_DPM_SET_LIMITED_DISCOVERABLE_STATE:
2818 case BT_DPM_GET_LIMITED_DISCOVERABLE_STATE:
2819 case BT_DPM_SET_DATA_TRANSFER_STATE:
2820 case BT_DPM_GET_DATA_TRANSFER_STATE:
2822 case BT_NETWORK_ACTIVATE:
2823 case BT_NETWORK_DEACTIVATE:
2824 case BT_NETWORK_CONNECT:
2825 case BT_NETWORK_DISCONNECT:
2826 case BT_NETWORK_SERVER_DISCONNECT:
2828 case BT_GATT_GET_PRIMARY_SERVICES:
2829 case BT_GATT_DISCOVER_CHARACTERISTICS:
2830 case BT_GATT_SET_PROPERTY_REQUEST:
2831 case BT_GATT_READ_CHARACTERISTIC:
2832 case BT_GATT_DISCOVER_CHARACTERISTICS_DESCRIPTOR:
2833 case BT_GATT_REGISTER_APPLICATION:
2834 case BT_GATT_REGISTER_SERVICE:
2835 case BT_GATT_SEND_RESPONSE:
2837 case BT_REQ_ATT_MTU:
2838 case BT_PBAP_CONNECT:
2839 case BT_PBAP_DISCONNECT:
2840 case BT_PBAP_GET_PHONEBOOK_SIZE:
2841 case BT_PBAP_GET_PHONEBOOK:
2842 case BT_PBAP_GET_LIST:
2843 case BT_PBAP_PULL_VCARD:
2844 case BT_PBAP_PHONEBOOK_SEARCH:
2845 case BT_AUDIO_SELECT_ROLE:
2847 ret_val = cynara_check(p_cynara, client_creds, client_session, user_creds,
2848 BT_PRIVILEGE_PUBLIC);
2850 if (ret_val != CYNARA_API_ACCESS_ALLOWED) {
2851 BT_ERR("Fail to access: %s", BT_PRIVILEGE_PUBLIC);
2855 /* Need to check mediastorage privilege */
2856 if (function_name == BT_PBAP_GET_PHONEBOOK ||
2857 function_name == BT_PBAP_PULL_VCARD) {
2858 ret_val = cynara_check(p_cynara, client_creds, client_session, user_creds,
2859 MEDIASTORAGE_PRIVILEGE);
2861 if (ret_val != CYNARA_API_ACCESS_ALLOWED) {
2862 BT_ERR("Fail to access: %s", MEDIASTORAGE_PRIVILEGE);
2868 case BT_ENABLE_ADAPTER:
2869 case BT_DISABLE_ADAPTER:
2870 case BT_RESET_ADAPTER:
2871 case BT_RECOVER_ADAPTER:
2872 case BT_ENABLE_ADAPTER_LE:
2873 case BT_DISABLE_ADAPTER_LE:
2874 case BT_SET_CONNECTABLE:
2875 case BT_SET_DISCOVERABLE_MODE:
2876 case BT_ADD_WHITE_LIST:
2877 case BT_REMOVE_WHITE_LIST:
2878 case BT_CLEAR_WHITE_LIST:
2879 case BT_SET_MANUFACTURER_DATA:
2880 case BT_SET_PASSKEY_NOTIFICATION:
2881 case BT_SET_PROFILE_RESTRICTED:
2883 case BT_DISCONNECT_DEVICE:
2884 case BT_CANCEL_SEARCH_SERVICE:
2885 case BT_ENABLE_RSSI:
2887 case BT_RFCOMM_ACCEPT_CONNECTION:
2888 case BT_RFCOMM_REJECT_CONNECTION:
2889 case BT_RFCOMM_LISTEN:
2890 case BT_RFCOMM_CREATE_SOCKET_EX:
2891 case BT_RFCOMM_REMOVE_SOCKET_EX:
2893 case BT_HID_ENABLE_BARCODE_FEATURE:
2895 case BT_AVRCP_CONTROL_GET_PROPERTY:
2896 case BT_AVRCP_GET_TRACK_INFO:
2897 case BT_AVRCP_TRANSPORT_SET_PROPERTY:
2900 case BT_SET_CONTENT_PROTECT:
2901 case BT_BOND_DEVICE_BY_TYPE:
2902 case BT_SET_LE_PRIVACY:
2903 case BT_SET_LE_STATIC_RANDOM_ADDRESS:
2904 case BT_LE_CONN_UPDATE:
2905 case BT_UPDATE_LE_CONNECTION_MODE:
2906 case BT_GET_DEVICE_IDA:
2907 case BT_ENABLE_FORCE_HCI_DUMP:
2908 case BT_LE_READ_MAXIMUM_DATA_LENGTH:
2909 case BT_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH:
2910 case BT_LE_READ_HOST_SUGGESTED_DATA_LENGTH:
2911 case BT_LE_SET_DATA_LENGTH:
2912 case BT_LE_OOB_READ_LOCAL_DATA:
2913 case BT_LE_OOB_ADD_REMOTE_DATA:
2915 case BT_LE_IPSP_INIT:
2916 case BT_LE_IPSP_DEINIT:
2917 case BT_LE_IPSP_CONNECT:
2918 case BT_LE_IPSP_DISCONNECT:
2919 case BT_PXP_SET_PROPERTY:
2920 case BT_PXP_GET_PROPERTY:
2921 case BT_PXP_GET_SUPPORTED_SERIVCES:
2922 case BT_PXP_REGISTER_REPORTER:
2923 case BT_PXP_UNREGISTER_REPORTER:
2924 ret_val = cynara_check(p_cynara, client_creds, client_session, user_creds,
2925 BT_PRIVILEGE_PLATFORM);
2927 if (ret_val != CYNARA_API_ACCESS_ALLOWED) {
2928 BT_ERR("Fail to access: %s", BT_PRIVILEGE_PLATFORM);
2933 case BT_CHECK_ADAPTER:
2936 case BT_GET_LOCAL_NAME:
2937 case BT_GET_LOCAL_ADDRESS:
2938 case BT_GET_LOCAL_VERSION:
2939 case BT_IS_SERVICE_USED:
2940 case BT_GET_DISCOVERABLE_MODE:
2941 case BT_GET_DISCOVERABLE_TIME:
2942 case BT_IS_DISCOVERYING:
2943 case BT_IS_LE_DISCOVERYING:
2944 case BT_IS_CONNECTABLE:
2945 case BT_GET_BONDED_DEVICES:
2946 case BT_GET_PROFILE_CONNECTED_DEVICES:
2947 case BT_GET_BONDED_DEVICE:
2948 case BT_PASSKEY_REPLY:
2949 case BT_PASSKEY_CONFIRMATION_REPLY:
2950 case BT_GET_IS_ALIAS_SET:
2951 case BT_IS_DEVICE_CONNECTED:
2952 case BT_GET_CONNECTED_LINK_TYPE:
2953 case BT_SET_PROFILE_TRUSTED:
2954 case BT_GET_PROFILE_TRUSTED:
2955 case BT_GET_SPEAKER_GAIN:
2956 case BT_SET_SPEAKER_GAIN:
2957 case BT_OOB_READ_LOCAL_DATA:
2958 case BT_RFCOMM_CLIENT_IS_CONNECTED:
2959 case BT_RFCOMM_IS_UUID_AVAILABLE:
2960 case BT_GET_ADVERTISING_DATA:
2961 case BT_GET_SCAN_RESPONSE_DATA:
2962 case BT_IS_ADVERTISING:
2963 case BT_REGISTER_SCAN_FILTER:
2964 case BT_IS_SCAN_FILTER_SUPPORTED:
2965 case BT_GET_PROFILE_RESTRICTED:
2966 case BT_GET_ATT_MTU:
2968 case BT_OBEX_SERVER_ALLOCATE:
2969 case BT_OBEX_SERVER_DEALLOCATE:
2970 case BT_OBEX_SERVER_IS_ACTIVATED:
2971 case BT_OPP_GET_TRANSFER_PROGRESS:
2972 /* Non-privilege control */
2975 BT_ERR("Unknown function!");
2989 GDBusNodeInfo *__bt_service_create_method_node_info
2990 (const gchar *introspection_data)
2993 GDBusNodeInfo *node_info = NULL;
2995 if (introspection_data == NULL) {
2996 ERR("Introspection XML not present");
3000 node_info = g_dbus_node_info_new_for_xml(introspection_data, &err);
3003 ERR("Unable to create node: %s", err->message);
3004 g_clear_error(&err);
3009 int __bt_service_register_object(GDBusConnection *conn,
3010 GDBusNodeInfo *node_info, gboolean reg)
3012 static guint service_id = 0;
3013 GError *error = NULL;
3016 if (node_info == NULL)
3019 service_id = g_dbus_connection_register_object(conn,
3021 node_info->interfaces[0],
3023 NULL, NULL, &error);
3024 if (service_id == 0)
3027 if (service_id > 0) {
3028 g_dbus_connection_unregister_object(conn,
3037 static void __bt_service_bus_acquired_handler(GDBusConnection *connection,
3038 const gchar *name, gpointer user_data)
3040 GDBusNodeInfo *node_info = NULL;
3042 BT_INFO("bus acquired");
3044 ret_if(connection == NULL);
3046 node_info = __bt_service_create_method_node_info(
3047 bt_service_introspection_xml);
3048 ret_if(node_info == NULL);
3050 __bt_service_register_object(connection, node_info, TRUE);
3051 g_dbus_node_info_unref(node_info);
3053 bt_service_conn = connection;
3056 static void __bt_service_name_acquired_handler(GDBusConnection *connection,
3057 const gchar *name, gpointer user_data)
3059 BT_INFO("name acquired");
3060 name_acquired = TRUE;
3063 static void __bt_service_name_lost_handler(GDBusConnection *connection,
3064 const gchar *name, gpointer user_data)
3066 BT_INFO("name lost");
3067 name_acquired = FALSE;
3070 gboolean _is_name_acquired(void)
3072 return name_acquired;
3075 int _bt_service_register(void)
3077 GDBusConnection *conn;
3080 conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
3081 retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
3082 bt_service_conn = conn;
3084 owner_id = g_bus_own_name(G_BUS_TYPE_SYSTEM,
3086 G_BUS_NAME_OWNER_FLAGS_NONE,
3087 __bt_service_bus_acquired_handler,
3088 __bt_service_name_acquired_handler,
3089 __bt_service_name_lost_handler,
3091 BT_DBG("owner_id is [%d]", owner_id);
3095 return BLUETOOTH_ERROR_NONE;
3098 if (bt_service_conn) {
3099 g_object_unref(bt_service_conn);
3100 bt_service_conn = NULL;
3103 return BLUETOOTH_ERROR_INTERNAL;
3106 void _bt_service_unregister(void)
3108 if (bt_service_conn) {
3109 __bt_service_register_object(bt_service_conn, NULL, FALSE);
3110 if (bt_service_conn) {
3111 g_object_unref(bt_service_conn);
3112 bt_service_conn = NULL;
3115 g_bus_unown_name(owner_id);
3121 int _bt_service_cynara_init(void)
3124 char err_msg[256] = {0, };
3126 retv_if(p_cynara != NULL, BLUETOOTH_ERROR_ALREADY_INITIALIZED);
3128 result = cynara_initialize(&p_cynara, conf);
3130 if (result != CYNARA_API_SUCCESS) {
3131 cynara_strerror(result, err_msg, sizeof(err_msg));
3132 BT_ERR("Fail to initialize cynara: [%s]", err_msg);
3133 return BLUETOOTH_ERROR_INTERNAL;
3136 return BLUETOOTH_ERROR_NONE;
3139 void _bt_service_cynara_deinit(void)
3142 char err_msg[256] = {0, };
3144 ret_if(p_cynara == NULL);
3146 result = cynara_finish(p_cynara);
3148 if (result != CYNARA_API_SUCCESS) {
3149 cynara_strerror(result, err_msg, sizeof(err_msg));
3150 BT_ERR("Fail to finish cynara: [%s]", err_msg);