bt-service-adaptation/services/bt-request-handler.c

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   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
   7  *
   8  *              http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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.
  15  *
  16  */
  17
  18 #include <string.h>
  19 #include <stdio.h>
  20 #include <glib.h>
  21 #include <dlog.h>
  22 #include <gio/gio.h>
  23 #include <gio/gunixfdlist.h>
  24 #include <cynara-client.h>
  25 #include <cynara-creds-gdbus.h>
  26
  27 #include "bluetooth-api.h"
  28 #include "bluetooth-audio-api.h"
  29 #include "bluetooth-gatt-server-api.h"
  30 #include "bt-request-handler.h"
  31 #include "bt-service-common.h"
  32 #include "bt-service-util.h"
  33
  34 #include "bt-service-core-adapter.h"
  35 #include "bt-service-core-adapter-le.h"
  36 #include "bt-service-core-device.h"
  37
  38 #include "bt-service-audio-common.h"
  39 #include "bt-service-avrcp-tg.h"
  40 #include "bt-service-avrcp-ctrl.h"
  41 #include "bt-service-gatt.h"
  42
  43 #ifdef TIZEN_FEATURE_BT_DPM
  44 #include "bt-service-dpm.h"
  45 #endif
  46 #include "bt-service-hidhost.h"
  47 #include "bt-service-rfcomm.h"
  48 #include "bt-service-hdp.h"
  49
  50 /*Obex*/
  51 #include "bt-service-obex-server.h"
  52 #include "bt-service-opp-client.h"
  53 #include "bt-service-map-client.h"
  54 #include "bt-service-pbap.h"
  55 #include "bt-service-oob.h"
  56
  57 #ifdef TIZEN_FEATURE_BT_PAN_NAP
  58 #include "bt-service-network.h"
  59 #endif
  60
  61 #ifdef TIZEN_FEATURE_BT_IPSP
  62 #include "bt-service-ipsp.h"
  63 #endif
  64 /* For maintaining Application Sync API call requests */
  65 GSList *invocation_list = NULL;
  66
  67 static GDBusConnection *bt_service_conn;
  68 static guint owner_id = 0;
  69 static guint owner_sig_id = 0;
  70 static gboolean is_le_intended = FALSE;
  71
  72
  73 static cynara *p_cynara;
  74 static cynara_configuration *conf;
  75
  76 static const gchar bt_service_introspection_xml[] =
  77 "<node name='/org/projectx/bt_service'>"
  78 "       <interface name='org.projectx.bt'>"
  79 "               <method name='service_request'>"
  80                         /* Input Parameters */
  81 "                       <arg type='i' name='service_type' direction='in' />"
  82 "                       <arg type='i' name='service_function' direction='in' />"
  83 "                       <arg type='i' name='request_type' direction='in' />"
  84 "                       <arg type='ay' name='input_param1' direction='in' />"
  85 "                       <arg type='ay' name='input_param2' direction='in' />"
  86 "                       <arg type='ay' name='input_param3' direction='in' />"
  87 "                       <arg type='ay' name='input_param4' direction='in' />"
  88 "                       <arg type='ay' name='input_param5' direction='in' />"
  89                         /* Return Parameters */
  90 "                       <arg type='i' name='output_param1' direction='out' />"
  91 "                       <arg type='v' name='output_param2' direction='out' />"
  92 "               </method>"
  93 "       </interface>"
  94 "</node>";
  95
  96 static gboolean name_acquired = FALSE;
  97
  98 static char *current_sender_playing = NULL;
  99
 100 GDBusNodeInfo *node_info_g = NULL;
 101
 102 static void __bt_service_method(GDBusConnection *connection,
 103                 const gchar *sender,
 104                 const gchar *object_path,
 105                 const gchar *interface_name,
 106                 const gchar *method_name,
 107                 GVariant *parameters,
 108                 GDBusMethodInvocation *invocation,
 109                 gpointer user_data);
 110
 111 int __bt_bluez_request(int function_name,
 112                 int request_type,
 113                 int request_id,
 114                 GDBusMethodInvocation *context,
 115                 GVariant *in_param1,
 116                 GVariant *in_param2,
 117                 GVariant *in_param3,
 118                 GVariant *in_param4,
 119                 GArray **out_param1);
 120 int __bt_obexd_request(int function_name,
 121                 int request_type,
 122                 int request_id,
 123                 GDBusMethodInvocation *context,
 124                 GVariant *in_param1,
 125                 GVariant *in_param2,
 126                 GVariant *in_param3,
 127                 GVariant *in_param4,
 128                 GArray **out_param1);
 129 int __bt_agent_request(int function_name,
 130                 int request_type,
 131                 int request_id,
 132                 GDBusMethodInvocation *context,
 133                 GVariant *in_param1,
 134                 GVariant *in_param2,
 135                 GVariant *in_param3,
 136                 GVariant *in_param4,
 137                 GArray **out_param1);
 138 int __bt_core_request(int function_name,
 139                 int request_type,
 140                 int request_id,
 141                 GDBusMethodInvocation *context,
 142                 GVariant *in_param1);
 143
 144 gboolean __bt_service_check_privilege(int function_name,
 145                                         int service_type,
 146                                         const char *unique_name);
 147
 148 /* Function definitions*/
 149 GSList *_bt_get_invocation_list(void)
 150 {
 151         return invocation_list;
 152 }
 153
 154 void _bt_free_info_from_invocation_list(invocation_info_t *req_info)
 155 {
 156         GSList *l;
 157         invocation_info_t *info;
 158
 159         ret_if(NULL == req_info);
 160         ret_if(NULL == req_info->sender);
 161
 162         for (l = invocation_list; l != NULL; l = g_slist_next(l)) {
 163                 info = l->data;
 164                 if (NULL == info || NULL == info->sender)
 165                         continue;
 166
 167                 /* No two same sync requests from same application can exist */
 168                 if ((strcasecmp(info->sender, req_info->sender) == 0) &&
 169                                 req_info->service_function == info->service_function) {
 170
 171                         invocation_list = g_slist_remove(invocation_list, req_info);
 172                         g_free(req_info->sender);
 173                         g_free(req_info);
 174                         break;
 175                 }
 176         }
 177
 178 }
 179
 180 void _bt_set_le_intended_status(gboolean value)
 181 {
 182         is_le_intended = value;
 183 }
 184
 185 static void __bt_service_get_parameters(GVariant *in_param,
 186                 void *value, int size)
 187 {
 188         void *buf = NULL;
 189         buf = (void *)g_variant_get_data(in_param);
 190         memcpy(value, buf, size);
 191 }
 192
 193 static gboolean __bt_is_sync_function(int service_function)
 194 {
 195         /*TODO: Keep adding sync methods with expect replies from bluetooth service */
 196         if (service_function == BT_ENABLE_ADAPTER
 197                         || service_function == BT_DISABLE_ADAPTER
 198                         || service_function == BT_GET_LOCAL_ADDRESS
 199                         || service_function == BT_GET_LOCAL_NAME
 200                         || service_function == BT_GET_LOCAL_VERSION
 201                         || service_function == BT_GET_BONDED_DEVICES
 202                         || service_function == BT_GET_BONDED_DEVICE
 203                         || service_function == BT_GET_IS_ALIAS_SET
 204                         || service_function == BT_GET_CONNECTED_LINK_TYPE
 205                         || service_function == BT_IS_SERVICE_USED
 206                         || service_function == BT_RFCOMM_LISTEN_AND_ACCEPT
 207                         || service_function == BT_RFCOMM_LISTEN
 208                         || service_function == BT_HDP_REGISTER_SINK_APP
 209                         || service_function == BT_HDP_UNREGISTER_SINK_APP
 210                         || service_function == BT_HDP_GET_FD
 211                         || service_function == BT_AVRCP_GET_TRACK_INFO
 212                         || service_function == BT_AVRCP_CONTROL_GET_PROPERTY
 213                         || service_function == BT_SET_ADVERTISING_DATA
 214                         || service_function == BT_SET_SCAN_RESPONSE_DATA
 215                         || service_function == BT_SET_ADVERTISING
 216                         || service_function == BT_SET_CUSTOM_ADVERTISING
 217                         || service_function == BT_GATT_SERVER_REGISTER
 218                         || service_function == BT_GATT_SERVER_ADD_SERVICE
 219                         || service_function == BT_GATT_SERVER_ADD_CHARACTERISTIC
 220                         || service_function == BT_GATT_SERVER_ADD_DESCRIPTOR
 221                         || service_function == BT_GATT_SERVER_START_SERVICE
 222                         || service_function == BT_GATT_SERVER_STOP_SERVICE
 223                         || service_function == BT_GATT_SERVER_DELETE_SERVICE
 224                         || service_function == BT_START_LE_DISCOVERY
 225                         || service_function == BT_STOP_LE_DISCOVERY
 226 #ifdef TIZEN_GATT_CLIENT
 227                         || service_function == BT_GATT_CLIENT_REGISTER
 228                         || service_function == BT_GATT_GET_PRIMARY_SERVICES
 229                         || service_function == BT_GATT_GET_SERVICE_PROPERTIES
 230                         || service_function == BT_GATT_GET_INCLUDED_SERVICES
 231                         || service_function == BT_GATT_GET_CHARACTERISTIC_PROPERTIES
 232                         || service_function == BT_GATT_WATCH_CHARACTERISTIC
 233                         || service_function == BT_GATT_ACQUIRE_WRITE
 234 #endif
 235                         || service_function == BT_AUDIO_SELECT_ROLE
 236                         || service_function == BT_OBEX_SERVER_ACCEPT_CONNECTION)
 237                 return TRUE;
 238         else
 239                 return FALSE;
 240 }
 241
 242 void _bt_save_invocation_context(GDBusMethodInvocation *invocation, int result,
 243                 char *sender, int service_function,
 244                 gpointer invocation_data)
 245 {
 246         BT_DBG("Saving the invocation context: service_function [%d]", service_function);
 247         invocation_info_t *info;
 248         info = g_malloc0(sizeof(invocation_info_t));
 249         info->context = invocation;
 250         info->result = result;
 251         info->sender = g_strdup(sender);
 252         info->service_function = service_function;
 253         info->user_data = invocation_data;
 254         invocation_list = g_slist_append(invocation_list, info);
 255
 256 }
 257
 258 static void __bt_service_method(GDBusConnection *connection,
 259                 const gchar *sender,
 260                 const gchar *object_path,
 261                 const gchar *interface_name,
 262                 const gchar *method_name,
 263                 GVariant *parameters,
 264                 GDBusMethodInvocation *invocation,
 265                 gpointer user_data)
 266 {
 267         FN_START;
 268
 269         BT_DBG("Method[%s] Object Path[%s] Interface Name[%s]",
 270                         method_name, object_path, interface_name);
 271
 272         if (g_strcmp0(method_name, "service_request") == 0) {
 273                 int service_type;
 274                 int service_function;
 275                 int request_type;
 276                 GVariant *param1 = NULL;
 277                 GVariant *param2 = NULL;
 278                 GVariant *param3 = NULL;
 279                 GVariant *param4 = NULL;
 280                 GVariant *param5 = NULL;
 281                 GArray *out_param1 = NULL;
 282                 GVariant *out_var = NULL;
 283                 GVariant *temp = NULL;
 284                 int result = 0;
 285                 int request_id = -1;
 286
 287                 g_variant_get(parameters, "(iii@ay@ay@ay@ay@ay)", &service_type,
 288                                 &service_function, &request_type,
 289                                 &param1, &param2, &param3, &param4, &param5);
 290
 291                 out_param1 = g_array_new(FALSE, FALSE, sizeof(gchar));
 292
 293                 if (service_type == BT_CORE_SERVICE) {
 294                         BT_DBG("No need to check privilege from bt-core");
 295                 } else if (__bt_service_check_privilege(service_function,
 296                                         service_type, (const char *)sender) == FALSE) {
 297                         BT_ERR("Client don't have the privilege to excute this function");
 298                         result = BLUETOOTH_ERROR_PERMISSION_DEINED;
 299                         goto fail;
 300                 }
 301
 302                 BT_DBG("SERVICE TYPE [%d] SERVICE FUNC [%d]",
 303                                 service_type, service_function);
 304                 switch (service_type) {
 305                 case BT_BLUEZ_SERVICE:
 306                         result = __bt_bluez_request(service_function,
 307                                         request_type, request_id,
 308                                         invocation, param1, param2,
 309                                         param3, param4, &out_param1);
 310                         break;
 311                 case BT_OBEX_SERVICE:
 312                         result = __bt_obexd_request(service_function,
 313                                         request_type, request_id,
 314                                         invocation, param1,
 315                                         param2, param3,
 316                                         param4, &out_param1);
 317                         break;
 318                 case BT_AGENT_SERVICE:
 319                         result = __bt_agent_request(service_function,
 320                                         request_type, request_id,
 321                                         invocation, param1,
 322                                         param2, param3,
 323                                         param4, &out_param1);
 324                         break;
 325                 case BT_CORE_SERVICE:
 326                         result = __bt_core_request(service_function,
 327                                         request_type, request_id,
 328                                         invocation, param1);
 329                         break;
 330                 case BT_CHECK_PRIVILEGE:
 331                         result = BLUETOOTH_ERROR_NONE;
 332                         break;
 333                 default:
 334                         BT_ERR("Unknown service type");
 335                         result = BLUETOOTH_ERROR_INTERNAL;
 336                         goto fail;
 337                 }
 338
 339                 if (result != BLUETOOTH_ERROR_NONE)
 340                         goto fail;
 341
 342                 if (service_type == BT_CHECK_PRIVILEGE)
 343                         goto send_reply;
 344
 345                 if (service_function == BT_OPP_PUSH_FILES)
 346                         goto done;
 347
 348                 if (request_type == BT_ASYNC_REQ ||
 349                                 __bt_is_sync_function(service_function)) {
 350                         BT_INFO("Do not send reply to bt-api over dbus,"
 351                                 " Invocation context is already saved in service_function");
 352                         goto done;
 353                 }
 354
 355 send_reply:
 356                 out_var = g_variant_new_from_data((const GVariantType *)"ay",
 357                                 out_param1->data, out_param1->len,
 358                                 TRUE, NULL, NULL);
 359
 360                 temp = g_variant_new("(iv)", result, out_var);
 361                 g_dbus_method_invocation_return_value(invocation, temp);
 362                 g_array_free(out_param1, TRUE);
 363                 out_param1 = NULL;
 364
 365 done:
 366                 g_variant_unref(param1);
 367                 g_variant_unref(param2);
 368                 g_variant_unref(param3);
 369                 g_variant_unref(param4);
 370                 g_variant_unref(param5);
 371                 FN_END;
 372                 return;
 373 fail:
 374                 BT_ERR_C("Request is failed [%s] [0x%x]",
 375                                 _bt_convert_error_to_string(result), result);
 376
 377                 out_var = g_variant_new_from_data((const GVariantType *)"ay",
 378                                 out_param1->data, out_param1->len,
 379                                 TRUE, NULL, NULL);
 380
 381                 temp = g_variant_new("(iv)", result, out_var);
 382                 g_dbus_method_invocation_return_value(invocation, temp);
 383
 384                 g_array_free(out_param1, TRUE);
 385                 out_param1 = NULL;
 386
 387                 g_variant_unref(param1);
 388                 g_variant_unref(param2);
 389                 g_variant_unref(param3);
 390                 g_variant_unref(param4);
 391                 g_variant_unref(param5);
 392         }
 393
 394         FN_END;
 395         return;
 396 }
 397
 398
 399 static const GDBusInterfaceVTable method_table = {
 400         __bt_service_method,
 401         NULL,
 402         NULL,
 403         {0}
 404 };
 405
 406 int __bt_bluez_request(int function_name,
 407                 int request_type,
 408                 int request_id,
 409                 GDBusMethodInvocation *context,
 410                 GVariant *in_param1,
 411                 GVariant *in_param2,
 412                 GVariant *in_param3,
 413                 GVariant *in_param4,
 414                 GArray **out_param1)
 415 {
 416         int result = BLUETOOTH_ERROR_NONE;
 417         char *sender = NULL;
 418
 419         switch (function_name) {
 420         case BT_ENABLE_ADAPTER: {
 421                 result = _bt_enable_adapter();
 422                 /* Save invocation */
 423                 if (result == BLUETOOTH_ERROR_NONE) {
 424                         BT_DBG("_bt_enable_adapter scheduled successfully! save invocation context");
 425                         sender = (char*)g_dbus_method_invocation_get_sender(context);
 426                         _bt_save_invocation_context(context, result, sender,
 427                                         function_name, NULL);
 428                 }
 429                 break;
 430         }
 431         case BT_DISABLE_ADAPTER: {
 432                 result = _bt_disable_adapter();
 433                 /* Save invocation */
 434                 if (result == BLUETOOTH_ERROR_NONE) {
 435                         BT_DBG("_bt_disable_adapter scheduled successfully! save invocation context");
 436                         sender = (char*)g_dbus_method_invocation_get_sender(context);
 437                         _bt_save_invocation_context(context, result, sender,
 438                                         function_name, NULL);
 439                 }
 440                 break;
 441         }
 442         case BT_RECOVER_ADAPTER:
 443                  result = _bt_recover_adapter();
 444                  break;
 445         case BT_RESET_ADAPTER:
 446                 result = _bt_reset_adapter();
 447                 break;
 448         case BT_CHECK_ADAPTER: {
 449                 int enabled = BT_ADAPTER_DISABLED;
 450                 result = _bt_check_adapter(&enabled);
 451
 452                 g_array_append_vals(*out_param1, &enabled,
 453                                 sizeof(int));
 454                 break;
 455         }
 456         case BT_ENABLE_ADAPTER_LE:
 457                 _bt_set_le_intended_status(TRUE);
 458                 result = _bt_enable_adapter_le();
 459                 break;
 460         case BT_DISABLE_ADAPTER_LE:
 461                 _bt_set_le_intended_status(FALSE);
 462                 result = _bt_disable_adapter_le();
 463                 break;
 464         case BT_START_DISCOVERY: {
 465                 unsigned short max_response;
 466                 unsigned short discovery_duration;
 467                 unsigned int classOfDeviceMask;
 468
 469                 __bt_service_get_parameters(in_param1,
 470                                 &max_response, sizeof(unsigned short));
 471                 __bt_service_get_parameters(in_param2,
 472                                 &discovery_duration, sizeof(unsigned short));
 473                 __bt_service_get_parameters(in_param3,
 474                                 &classOfDeviceMask, sizeof(unsigned int));
 475
 476                 result = _bt_start_discovery(max_response, discovery_duration, classOfDeviceMask);
 477                 break;
 478         }
 479         case BT_START_CUSTOM_DISCOVERY: {
 480                 bt_discovery_role_type_t role;
 481
 482                 __bt_service_get_parameters(in_param1,
 483                                 &role, sizeof(bt_discovery_role_type_t));
 484                 result = _bt_start_custom_discovery(role);
 485
 486                 break;
 487         }
 488         case BT_CANCEL_DISCOVERY:
 489                 result = _bt_cancel_discovery();
 490                 break;
 491         case BT_IS_DISCOVERYING: {
 492                 gboolean discovering = FALSE;
 493                 discovering = _bt_is_discovering();
 494                 g_array_append_vals(*out_param1,
 495                                 &discovering, sizeof(gboolean));
 496                 break;
 497         }
 498         case BT_GET_LOCAL_ADDRESS: {
 499                 result = _bt_get_local_address();
 500
 501                 /* Save invocation */
 502                 if (result == BLUETOOTH_ERROR_NONE) {
 503                         sender = (char*)g_dbus_method_invocation_get_sender(context);
 504                         _bt_save_invocation_context(context, result, sender,
 505                                         function_name, NULL);
 506                 }
 507                 break;
 508         }
 509         case BT_GET_LOCAL_VERSION: {
 510                 result = _bt_get_local_version();
 511
 512                 /* Save invocation */
 513                 if (result == BLUETOOTH_ERROR_NONE) {
 514                         sender = (char*)g_dbus_method_invocation_get_sender(context);
 515                         _bt_save_invocation_context(context, result, sender,
 516                                         function_name, NULL);
 517                 }
 518                 break;
 519         }
 520         case BT_GET_LOCAL_NAME: {
 521                 result = _bt_get_local_name();
 522
 523                 /* Save invocation */
 524                 if (result == BLUETOOTH_ERROR_NONE) {
 525                         sender = (char*)g_dbus_method_invocation_get_sender(context);
 526                         _bt_save_invocation_context(context, result, sender,
 527                                         function_name, NULL);
 528                 }
 529                 break;
 530         }
 531         case BT_SET_LOCAL_NAME: {
 532                 bluetooth_device_name_t local_name = { {0} };
 533                 __bt_service_get_parameters(in_param1,
 534                                 &local_name, sizeof(bluetooth_device_name_t));
 535                 result = _bt_set_local_name(local_name.name);
 536                 break;
 537         }
 538         case BT_GET_DISCOVERABLE_MODE: {
 539                 int discoverable_mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
 540                 result = _bt_get_discoverable_mode(&discoverable_mode);
 541                 g_array_append_vals(*out_param1, &discoverable_mode, sizeof(int));
 542                 break;
 543         }
 544         case BT_GET_DISCOVERABLE_TIME: {
 545                 int timeout = 0;
 546
 547                 result = _bt_get_timeout_value(&timeout);
 548                 g_array_append_vals(*out_param1, &timeout, sizeof(int));
 549                 break;
 550         }
 551         case BT_SET_DISCOVERABLE_MODE: {
 552                 int mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
 553                 int time = 0;
 554
 555                 __bt_service_get_parameters(in_param1, &mode, sizeof(int));
 556                 __bt_service_get_parameters(in_param2, &time, sizeof(int));
 557
 558                 result = _bt_set_discoverable_mode(mode, time);
 559                 break;
 560         }
 561         case BT_IS_CONNECTABLE: {
 562                 gboolean is_connectable = FALSE;
 563
 564                 is_connectable = _bt_is_connectable();
 565                 g_array_append_vals(*out_param1, &is_connectable, sizeof(gboolean));
 566                 break;
 567         }
 568         case BT_SET_CONNECTABLE: {
 569                 gboolean is_connectable;
 570
 571                 __bt_service_get_parameters(in_param1,
 572                                 &is_connectable, sizeof(gboolean));
 573                 result = _bt_set_connectable(is_connectable);
 574                 break;
 575         }
 576         case BT_IS_SERVICE_USED: {
 577                 char *uuid = NULL;
 578
 579                 uuid = (char *)g_variant_get_data(in_param1);
 580                 BT_INFO("UUID to be searched [%s]", uuid);
 581                 result = _bt_is_service_used();
 582
 583                 /* Save invocation */
 584                 if (result == BLUETOOTH_ERROR_NONE) {
 585                         sender = (char*)g_dbus_method_invocation_get_sender(context);
 586                         _bt_save_invocation_context(context, result, sender,
 587                                         function_name, (gpointer)uuid);
 588                 }
 589                 break;
 590         }
 591         case BT_GET_BONDED_DEVICES: {
 592                 result = _bt_get_bonded_devices();
 593                 /* Save invocation */
 594                 if (result == BLUETOOTH_ERROR_NONE) {
 595                         sender = (char*)g_dbus_method_invocation_get_sender(context);
 596                         _bt_save_invocation_context(context, result, sender,
 597                                         function_name, NULL);
 598                 }
 599                 break;
 600         }
 601         case BT_GET_BONDED_DEVICE: {
 602                 bluetooth_device_address_t address = { {0} };
 603
 604                 __bt_service_get_parameters(in_param1,
 605                                 &address, sizeof(bluetooth_device_address_t));
 606
 607                 result = _bt_get_bonded_device_info(&address);
 608                 /* Save invocation */
 609                 if (result == BLUETOOTH_ERROR_NONE) {
 610                         char *addr = g_malloc0(sizeof(char) * BT_ADDRESS_STRING_SIZE);
 611                         if (!addr) {
 612                                 result = BLUETOOTH_ERROR_MEMORY_ALLOCATION;
 613                                 break;
 614                         }
 615
 616                         _bt_convert_addr_type_to_string(addr, address.addr);
 617                         sender = (char*)g_dbus_method_invocation_get_sender(context);
 618                         _bt_save_invocation_context(context, result, sender,
 619                                         function_name, addr);
 620                 }
 621                 break;
 622         }
 623         case BT_GET_PROFILE_CONNECTED_DEVICES: {
 624                 char *uuid;
 625                 uuid = (char *)g_variant_get_data(in_param1);
 626                 result = _bt_get_profile_connected_devices(uuid, out_param1);
 627                 break;
 628         }
 629         case BT_SET_ALIAS: {
 630                 bluetooth_device_address_t address = { {0} };
 631                 const char *local_name;
 632
 633                 __bt_service_get_parameters(in_param1,
 634                                 &address, sizeof(bluetooth_device_address_t));
 635                 local_name = (const char *)g_variant_get_data(in_param2);
 636
 637                 result = _bt_set_alias(&address, local_name);
 638                 break;
 639         }
 640         case BT_BOND_DEVICE: {
 641                 bluetooth_device_address_t address = { {0} };
 642
 643                 __bt_service_get_parameters(in_param1,
 644                                 &address, sizeof(bluetooth_device_address_t));
 645                 result = _bt_bond_device(&address, BLUETOOTH_DEV_CONN_DEFAULT, out_param1);
 646
 647                 /* Save invocation */
 648                 if (result == BLUETOOTH_ERROR_NONE) {
 649                         char * addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
 650                         _bt_convert_addr_type_to_string(addr, address.addr);
 651                         BT_DBG("_bt_bond_device scheduled successfully! save invocation context");
 652                         sender = (char*)g_dbus_method_invocation_get_sender(context);
 653                         _bt_save_invocation_context(context, result, sender,
 654                                         function_name, (gpointer)addr);
 655                 } else {
 656                         bluetooth_device_info_t dev_info;
 657
 658                         memset(&dev_info, 0x00, sizeof(bluetooth_device_info_t));
 659                         memcpy(&dev_info.device_address, &address,
 660                                         sizeof(bluetooth_device_address_t));
 661                         g_array_append_vals(*out_param1, &dev_info,
 662                                         sizeof(bluetooth_device_info_t));
 663                 }
 664                 break;
 665         }
 666         case BT_BOND_DEVICE_BY_TYPE: {
 667                 bluetooth_device_address_t address = { {0} };
 668                 unsigned short conn_type = 0;
 669
 670                 __bt_service_get_parameters(in_param1,
 671                                 &address, sizeof(bluetooth_device_address_t));
 672                 __bt_service_get_parameters(in_param2,
 673                                 &conn_type, sizeof(unsigned short));
 674
 675                 result = _bt_bond_device(&address, conn_type, out_param1);
 676                 /* Save invocation */
 677                 if (result == BLUETOOTH_ERROR_NONE) {
 678                         char * addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
 679                         _bt_convert_addr_type_to_string(addr, address.addr);
 680                         BT_DBG("_bt_bond_device_by_type invoked successfully! save invocation context");
 681                         sender = (char*)g_dbus_method_invocation_get_sender(context);
 682                         _bt_save_invocation_context(context, result, sender,
 683                                         function_name, (gpointer)addr);
 684                 } else {
 685                         bluetooth_device_info_t dev_info;
 686
 687                         memset(&dev_info, 0x00, sizeof(bluetooth_device_info_t));
 688                         memcpy(&dev_info.device_address, &address,
 689                                         sizeof(bluetooth_device_address_t));
 690                         g_array_append_vals(*out_param1, &dev_info,
 691                                         sizeof(bluetooth_device_info_t));
 692                 }
 693                 break;
 694         }
 695         case BT_UNBOND_DEVICE: {
 696                 bluetooth_device_address_t address = { {0} };
 697
 698                 __bt_service_get_parameters(in_param1,
 699                                 &address, sizeof(bluetooth_device_address_t));
 700                 result = _bt_unbond_device(&address, out_param1);
 701
 702                 /* Save invocation */
 703                 if (result == BLUETOOTH_ERROR_NONE) {
 704                         char * addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
 705                         _bt_convert_addr_type_to_string(addr, address.addr);
 706                         BT_DBG("_bt_unbond_device scheduled successfully! save invocation context");
 707                         sender = (char*)g_dbus_method_invocation_get_sender(context);
 708                         _bt_save_invocation_context(context, result, sender,
 709                                         function_name, (gpointer)addr);
 710                 } else {
 711                         g_array_append_vals(*out_param1, &address,
 712                                         sizeof(bluetooth_device_address_t));
 713                 }
 714                 break;
 715         }
 716         case BT_CANCEL_BONDING:{
 717                 result = _bt_cancel_bonding();
 718                 break;
 719         }
 720         case BT_SEARCH_SERVICE: {
 721                 bluetooth_device_address_t address = { {0} };
 722                 __bt_service_get_parameters(in_param1,
 723                                 &address, sizeof(bluetooth_device_address_t));
 724                 result = _bt_search_device(&address);
 725                 /* Save invocation */
 726                 if (result == BLUETOOTH_ERROR_NONE) {
 727                         char * addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
 728                         _bt_convert_addr_type_to_string(addr, address.addr);
 729                         BT_DBG("BT Device Service Search Request scheduled successfully! save invocation context");
 730                         sender = (char*)g_dbus_method_invocation_get_sender(context);
 731                         _bt_save_invocation_context(context, result, sender,
 732                                         function_name, (gpointer)addr);
 733                 } else {
 734                         bt_sdp_info_t sdp_info;
 735
 736                         memset(&sdp_info, 0x00, sizeof(bt_sdp_info_t));
 737                         memcpy(&sdp_info.device_addr, &address,
 738                                         sizeof(bluetooth_device_address_t));
 739                         g_array_append_vals(*out_param1, &sdp_info, sizeof(bt_sdp_info_t));
 740                 }
 741                 break;
 742         }
 743         case BT_CANCEL_SEARCH_SERVICE: {
 744                 result = _bt_cancel_search_device();
 745                 break;
 746         }
 747         case BT_SET_PASSKEY_NOTIFICATION: {
 748                 char *sender = NULL;
 749                 gboolean enable;
 750
 751                 sender = (char *)g_dbus_method_invocation_get_sender(context);
 752                 __bt_service_get_parameters(in_param1,
 753                                 &enable, sizeof(gboolean));
 754
 755                 result = _bt_set_passkey_notification(sender, enable);
 756                 break;
 757         }
 758         case BT_SET_PIN_CODE: {
 759                 bluetooth_device_address_t address = { {0} };
 760                 bluetooth_device_pin_code_t pin_code = { {0} };
 761
 762                 __bt_service_get_parameters(in_param1,
 763                                 &address, sizeof(bluetooth_device_address_t));
 764                 __bt_service_get_parameters(in_param2,
 765                                 &pin_code, sizeof(bluetooth_device_pin_code_t));
 766
 767                 result = _bt_set_pin_code(&address, &pin_code);
 768                 break;
 769         }
 770         case BT_UNSET_PIN_CODE: {
 771                 bluetooth_device_address_t address = { {0} };
 772
 773                 __bt_service_get_parameters(in_param1,
 774                                 &address, sizeof(bluetooth_device_address_t));
 775
 776                 result = _bt_unset_pin_code(&address);
 777                 break;
 778         }
 779         case BT_PASSKEY_REPLY: {
 780                 const char *passkey = NULL;
 781                 gboolean authentication_reply = FALSE;
 782                 passkey = g_variant_get_data(in_param1);
 783                 __bt_service_get_parameters(in_param2,
 784                                 &authentication_reply, sizeof(gboolean));
 785                 result = _bt_passkey_reply(passkey, authentication_reply);
 786                 break;
 787         }
 788         case BT_PASSKEY_CONFIRMATION_REPLY: {
 789                 gboolean confirmation_reply = FALSE;
 790                 __bt_service_get_parameters(in_param1,
 791                                 &confirmation_reply, sizeof(gboolean));
 792                 result = _bt_passkey_confirmation_reply(confirmation_reply);
 793                 break;
 794         }
 795         case BT_GET_IS_ALIAS_SET: {
 796                 bluetooth_device_address_t address = { {0} };
 797
 798                 __bt_service_get_parameters(in_param1,
 799                                 &address, sizeof(bluetooth_device_address_t));
 800
 801                 result = _bt_is_alias_set(&address);
 802                 if (result == BLUETOOTH_ERROR_NONE) {
 803                         char *addr = g_malloc0(sizeof(char) * BT_ADDRESS_STRING_SIZE);
 804                         if (!addr) {
 805                                 result = BLUETOOTH_ERROR_MEMORY_ALLOCATION;
 806                                 break;
 807                         }
 808
 809                         _bt_convert_addr_type_to_string(addr, address.addr);
 810                         sender = (char*)g_dbus_method_invocation_get_sender(context);
 811                         _bt_save_invocation_context(context, result, sender,
 812                                         function_name, addr);
 813                 }
 814                 break;
 815         }
 816         case BT_SET_AUTHORIZATION: {
 817                 bluetooth_device_address_t address = { {0} };
 818                 gboolean authorize;
 819                 __bt_service_get_parameters(in_param1,
 820                                 &address, sizeof(bluetooth_device_address_t));
 821                 __bt_service_get_parameters(in_param2,
 822                                 &authorize, sizeof(gboolean));
 823                 result = _bt_set_authorization(&address, authorize);
 824                 break;
 825         }
 826         case BT_IS_DEVICE_CONNECTED: {
 827                 bluetooth_device_address_t address = { {0} };
 828                 gboolean connected = FALSE;
 829                 int service_type;
 830
 831                 __bt_service_get_parameters(in_param1,
 832                                 &address, sizeof(bluetooth_device_address_t));
 833                 __bt_service_get_parameters(in_param2,
 834                                 &service_type, sizeof(int));
 835
 836 #if defined(TIZEN_FEATURE_BT_PAN_NAP)
 837                 if ((service_type == BLUETOOTH_NAP_SERVICE) || (service_type == BLUETOOTH_NAP_SERVER_SERVICE))
 838                         connected = _bt_is_nap_panu_device_connected(&address, service_type);
 839                 else
 840                         connected = _bt_is_device_connected(&address, service_type);
 841 #else
 842                 connected = _bt_is_device_connected(&address, service_type);
 843 #endif
 844                 BT_INFO("is_connected: %d", connected);
 845                 g_array_append_vals(*out_param1, &connected, sizeof(gboolean));
 846                 break;
 847         }
 848         case BT_GET_CONNECTED_LINK_TYPE: {
 849                 bluetooth_device_address_t address = { {0} };
 850
 851                 __bt_service_get_parameters(in_param1,
 852                                 &address, sizeof(bluetooth_device_address_t));
 853
 854                 result = _bt_get_connected_link(&address);
 855                 if (result == BLUETOOTH_ERROR_NONE) {
 856                         char *addr = g_malloc0(sizeof(char) * BT_ADDRESS_STRING_SIZE);
 857                         if (!addr) {
 858                                 result = BLUETOOTH_ERROR_MEMORY_ALLOCATION;
 859                                 break;
 860                         }
 861
 862                         _bt_convert_addr_type_to_string(addr, address.addr);
 863                         sender = (char*)g_dbus_method_invocation_get_sender(context);
 864                         _bt_save_invocation_context(context, result, sender,
 865                                         function_name, addr);
 866                 }
 867                 break;
 868         }
 869         case BT_ENABLE_RSSI: {
 870                 bluetooth_device_address_t bd_addr;
 871                 int link_type;
 872                 bt_rssi_threshold_t rssi_threshold;
 873                 int low_threshold;
 874                 int in_range_threshold;
 875                 int high_threshold;
 876
 877                 BT_DBG("Enable RSSI");
 878
 879                 __bt_service_get_parameters(in_param1,
 880                                 &bd_addr, sizeof(bluetooth_device_address_t));
 881                 __bt_service_get_parameters(in_param2,
 882                                 &link_type, sizeof(int));
 883                 __bt_service_get_parameters(in_param3,
 884                                 &rssi_threshold, sizeof(bt_rssi_threshold_t));
 885
 886                 low_threshold = rssi_threshold.low_threshold;
 887                 in_range_threshold = rssi_threshold.in_range_threshold;
 888                 high_threshold = rssi_threshold.high_threshold;
 889
 890                 result = _bt_enable_rssi(&bd_addr, link_type, low_threshold,
 891                                 in_range_threshold, high_threshold);
 892                 break;
 893         }
 894         case BT_GET_RSSI: {
 895                 int link_type;
 896                 bluetooth_device_address_t bd_addr;
 897
 898                 BT_DBG("Get RSSI Strength");
 899
 900                 __bt_service_get_parameters(in_param1,
 901                                 &bd_addr, sizeof(bluetooth_device_address_t));
 902                 __bt_service_get_parameters(in_param2,
 903                                 &link_type, sizeof(int));
 904
 905                 result = _bt_get_rssi_strength(&bd_addr, link_type);
 906                 break;
 907         }
 908         case BT_SET_PROFILE_TRUSTED: {
 909                 bluetooth_device_address_t bd_addr = { {0} };
 910                 int profile;
 911                 int trust;
 912
 913                 __bt_service_get_parameters(in_param1, &bd_addr,
 914                                 sizeof(bluetooth_device_address_t));
 915                 __bt_service_get_parameters(in_param2, &profile, sizeof(int));
 916                 __bt_service_get_parameters(in_param3, &trust, sizeof(int));
 917
 918                 result = _bt_set_trust_profile(&bd_addr, profile, trust);
 919                 break;
 920         }
 921         case BT_GET_PROFILE_TRUSTED: {
 922                 bluetooth_device_address_t bd_addr = { {0} };
 923                 int profile;
 924                 guint trusted_profile = 0;
 925
 926                 __bt_service_get_parameters(in_param1, &bd_addr,
 927                                 sizeof(bluetooth_device_address_t));
 928                 __bt_service_get_parameters(in_param2, &profile, sizeof(int));
 929
 930                 result = _bt_get_trust_profile(&bd_addr, profile, &trusted_profile);
 931                 BT_DBG("TRUST %d", trusted_profile);
 932                 if (result == BLUETOOTH_ERROR_NONE) {
 933                         g_array_append_vals(*out_param1, &trusted_profile,
 934                                         sizeof(guint));
 935                 }
 936
 937                 break;
 938         }
 939         case BT_HID_CONNECT: {
 940                 bluetooth_device_address_t address = { {0} };
 941
 942                 __bt_service_get_parameters(in_param1,
 943                                 &address, sizeof(bluetooth_device_address_t));
 944
 945                 result = _bt_hid_connect(&address);
 946                 if (result != BLUETOOTH_ERROR_NONE) {
 947                         g_array_append_vals(*out_param1, &address,
 948                                         sizeof(bluetooth_device_address_t));
 949                 } else {
 950                         char *addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
 951                         _bt_convert_addr_type_to_string(addr, address.addr);
 952                         sender = (char*)g_dbus_method_invocation_get_sender(context);
 953                         _bt_save_invocation_context(context, result, sender,
 954                                         function_name, (gpointer)addr);
 955                 }
 956                 break;
 957         }
 958         case BT_HID_DISCONNECT: {
 959                 bluetooth_device_address_t address = { {0} };
 960
 961                 __bt_service_get_parameters(in_param1,
 962                                 &address, sizeof(bluetooth_device_address_t));
 963
 964                 result = _bt_hid_disconnect(&address);
 965                 if (result != BLUETOOTH_ERROR_NONE) {
 966                         g_array_append_vals(*out_param1, &address,
 967                                         sizeof(bluetooth_device_address_t));
 968                 } else {
 969                         char *addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
 970                         _bt_convert_addr_type_to_string(addr, address.addr);
 971                         sender = (char*)g_dbus_method_invocation_get_sender(context);
 972                         _bt_save_invocation_context(context, result, sender,
 973                                         function_name, (gpointer)addr);
 974                 }
 975                 break;
 976         }
 977 #ifdef TIZEN_FEATURE_BT_DPM
 978         case BT_DPM_SET_ALLOW_BT_MODE: {
 979                 dpm_bt_allow_t value = DPM_BT_ERROR;
 980
 981                 __bt_service_get_parameters(in_param1, &value,
 982                                 sizeof(int));
 983
 984                 result = _bt_dpm_set_allow_bluetooth_mode(value);
 985                 break;
 986         }
 987         case BT_DPM_GET_ALLOW_BT_MODE: {
 988                 int value = DPM_BT_ERROR;
 989
 990                 result = _bt_dpm_get_allow_bluetooth_mode(&value);
 991                 g_array_append_vals(*out_param1, &value, sizeof(int));
 992                 break;
 993         }
 994         case BT_DPM_SET_DEVICE_RESTRITION: {
 995                 dpm_status_t value = DPM_STATUS_ERROR;
 996
 997                 __bt_service_get_parameters(in_param1, &value,
 998                                 sizeof(int));
 999
1000                 result = _bt_dpm_activate_bluetooth_device_restriction(value);
1001                 break;
1002         }
1003         case BT_DPM_GET_DEVICE_RESTRITION: {
1004                 int value = DPM_STATUS_ERROR;
1005
1006                 result = _bt_dpm_is_bluetooth_device_restriction_active(&value);
1007                 g_array_append_vals(*out_param1, &value, sizeof(int));
1008                 break;
1009         }
1010         case BT_DPM_SET_UUID_RESTRITION: {
1011                 dpm_status_t value = DPM_STATUS_ERROR;
1012
1013                 __bt_service_get_parameters(in_param1, &value,
1014                                 sizeof(int));
1015
1016                 result = _bt_dpm_activate_bluetoooth_uuid_restriction(value);
1017                 break;
1018         }
1019         case BT_DPM_GET_UUID_RESTRITION: {
1020                 int value = DPM_STATUS_ERROR;
1021
1022                 result = _bt_dpm_is_bluetooth_uuid_restriction_active(&value);
1023                 g_array_append_vals(*out_param1, &value, sizeof(int));
1024                 break;
1025         }
1026         case BT_DPM_ADD_DEVICES_BLACKLIST: {
1027                 bluetooth_device_address_t address = { {0} };
1028
1029                 __bt_service_get_parameters(in_param1, &address,
1030                         sizeof(bluetooth_device_address_t));
1031
1032                 result = _bt_dpm_add_bluetooth_devices_to_blacklist(&address);
1033                 break;
1034         }
1035         case BT_DPM_ADD_DEVICES_WHITELIST: {
1036                 bluetooth_device_address_t address = { {0} };
1037
1038                 __bt_service_get_parameters(in_param1, &address,
1039                         sizeof(bluetooth_device_address_t));
1040
1041                 result = _bt_dpm_add_bluetooth_devices_to_whitelist(&address);
1042                 break;
1043         }
1044         case BT_DPM_ADD_UUIDS_BLACKLIST: {
1045                 const char *uuid = NULL;
1046
1047                 uuid = g_variant_get_data(in_param1);
1048
1049                 result = _bt_dpm_add_bluetooth_uuids_to_blacklist(uuid);
1050                 break;
1051         }
1052         case BT_DPM_ADD_UUIDS_WHITELIST: {
1053                 const char *uuid = NULL;
1054
1055                 uuid = g_variant_get_data(in_param1);
1056
1057                 result = _bt_dpm_add_bluetooth_uuids_to_whitelist(uuid);
1058                 break;
1059         }
1060         case BT_DPM_CLEAR_DEVICES_BLACKLIST: {
1061                 result = _bt_dpm_clear_bluetooth_devices_from_blacklist();
1062                 break;
1063         }
1064         case BT_DPM_CLEAR_DEVICES_WHITELIST: {
1065                 result = _bt_dpm_clear_bluetooth_devices_from_whitelist();
1066                 break;
1067         }
1068         case BT_DPM_CLEAR_UUIDS_BLACKLIST: {
1069                 result = _bt_dpm_clear_bluetooth_uuids_from_blacklist();
1070                 break;
1071         }
1072         case BT_DPM_CLEAR_UUIDS_WHITELIST: {
1073                 result = _bt_dpm_clear_bluetooth_uuids_from_whitelist();
1074                 break;
1075         }
1076         case BT_DPM_REMOVE_DEVICE_BLACKLIST: {
1077                 bluetooth_device_address_t address = { {0} };
1078
1079                 __bt_service_get_parameters(in_param1, &address,
1080                         sizeof(bluetooth_device_address_t));
1081
1082                 result = _bt_dpm_remove_bluetooth_devices_from_blacklist(&address);
1083                 break;
1084         }
1085         case BT_DPM_REMOVE_DEVICE_WHITELIST: {
1086                 bluetooth_device_address_t address = { {0} };
1087
1088                 __bt_service_get_parameters(in_param1, &address,
1089                         sizeof(bluetooth_device_address_t));
1090
1091                 result = _bt_dpm_remove_bluetooth_devices_from_whitelist(&address);
1092                 break;
1093         }
1094         case BT_DPM_REMOVE_UUID_BLACKLIST: {
1095                 const char *uuid = NULL;
1096
1097                 uuid = g_variant_get_data(in_param1);
1098
1099                 result = _bt_dpm_remove_bluetooth_uuids_from_blacklist(uuid);
1100                 break;
1101         }
1102         case BT_DPM_REMOVE_UUID_WHITELIST: {
1103                 const char *uuid = NULL;
1104
1105                 uuid = g_variant_get_data(in_param1);
1106
1107                 result = _bt_dpm_remove_bluetooth_uuids_from_whitelist(uuid);
1108
1109                 break;
1110         }
1111         case BT_DPM_GET_DEVICES_BLACKLIST: {
1112                 result = _bt_dpm_get_bluetooth_devices_from_blacklist(out_param1);
1113                 break;
1114         }
1115         case BT_DPM_GET_DEVICES_WHITELIST: {
1116                 result = _bt_dpm_get_bluetooth_devices_from_whitelist(out_param1);
1117                 break;
1118         }
1119         case BT_DPM_GET_UUIDS_BLACKLIST: {
1120                 result = _bt_dpm_get_bluetooth_uuids_from_blacklist(out_param1);
1121                 break;
1122         }
1123         case BT_DPM_GET_UUIDS_WHITELIST: {
1124                 result = _bt_dpm_get_bluetooth_uuids_from_whitelist(out_param1);
1125                 break;
1126         }
1127         case BT_DPM_SET_ALLOW_OUTGOING_CALL: {
1128                 dpm_status_t value = DPM_STATUS_ERROR;
1129
1130                 __bt_service_get_parameters(in_param1, &value,
1131                                 sizeof(int));
1132
1133                 result = _bt_dpm_set_allow_bluetooth_outgoing_call(value);
1134
1135                 break;
1136         }
1137         case BT_DPM_GET_ALLOW_OUTGOING_CALL: {
1138                 int value = DPM_STATUS_ERROR;
1139
1140                 result = _bt_dpm_get_allow_bluetooth_outgoing_call(&value);
1141                 g_array_append_vals(*out_param1, &value, sizeof(int));
1142                 break;
1143         }
1144         case BT_DPM_SET_PAIRING_STATE: {
1145                 dpm_status_t value = DPM_STATUS_ERROR;
1146
1147                 __bt_service_get_parameters(in_param1, &value,
1148                                 sizeof(int));
1149
1150                 result = _bt_dpm_set_bluetooth_pairing_state(value);
1151
1152                 break;
1153         }
1154         case BT_DPM_GET_PAIRING_STATE: {
1155                 int value = DPM_STATUS_ERROR;
1156
1157                 result = _bt_dpm_get_bluetooth_pairing_state(&value);
1158                 g_array_append_vals(*out_param1, &value, sizeof(int));
1159                 break;
1160         }
1161         case BT_DPM_SET_PROFILE_STATE: {
1162                 int value = DPM_STATUS_ERROR;
1163                 int profile = DPM_PROFILE_NONE;
1164
1165                 __bt_service_get_parameters(in_param1, &profile,
1166                                 sizeof(int));
1167                 __bt_service_get_parameters(in_param2, &value,
1168                                 sizeof(int));
1169
1170                 result = _bt_dpm_set_bluetooth_profile_state(profile, value);
1171
1172                 break;
1173         }
1174         case BT_DPM_GET_PROFILE_STATE: {
1175                 int value = DPM_STATUS_ERROR;
1176                 int profile = DPM_PROFILE_NONE;
1177
1178                 __bt_service_get_parameters(in_param1, &profile,
1179                                 sizeof(int));
1180
1181                 result = _bt_dpm_get_bluetooth_profile_state(profile, &value);
1182                 g_array_append_vals(*out_param1, &value, sizeof(int));
1183                 break;
1184         }
1185         case BT_DPM_SET_DESKROP_CONNECTIVITY_STATE: {
1186                 int value = DPM_BT_ERROR;
1187
1188                 __bt_service_get_parameters(in_param1, &value,
1189                                 sizeof(int));
1190
1191                 result = _bt_dpm_set_bluetooth_desktop_connectivity_state(value);
1192
1193                 break;
1194         }
1195         case BT_DPM_GET_DESKROP_CONNECTIVITY_STATE: {
1196                 int value = DPM_STATUS_ERROR;
1197
1198                 result = _bt_dpm_get_bluetooth_desktop_connectivity_state(&value);
1199                 g_array_append_vals(*out_param1, &value, sizeof(int));
1200                 break;
1201         }
1202         case BT_DPM_SET_DISCOVERABLE_STATE: {
1203                 int value = DPM_STATUS_ERROR;
1204
1205                 __bt_service_get_parameters(in_param1, &value,
1206                                 sizeof(int));
1207
1208                 result = _bt_dpm_set_bluetooth_discoverable_state(value);
1209
1210                 break;
1211         }
1212         case BT_DPM_GET_DISCOVERABLE_STATE: {
1213                 int value = DPM_STATUS_ERROR;
1214
1215                 result = _bt_dpm_get_bluetooth_discoverable_state(&value);
1216                 g_array_append_vals(*out_param1, &value, sizeof(int));
1217                 break;
1218         }
1219         case BT_DPM_SET_LIMITED_DISCOVERABLE_STATE: {
1220                 int value = DPM_STATUS_ERROR;
1221
1222                 __bt_service_get_parameters(in_param1, &value,
1223                                 sizeof(int));
1224
1225                 result = _bt_dpm_set_bluetooth_limited_discoverable_state(value);
1226
1227                 break;
1228         }
1229         case BT_DPM_GET_LIMITED_DISCOVERABLE_STATE: {
1230                 int value = DPM_STATUS_ERROR;
1231
1232                 result = _bt_dpm_get_bluetooth_limited_discoverable_state(&value);
1233                 g_array_append_vals(*out_param1, &value, sizeof(int));
1234                 break;
1235         }
1236         case BT_DPM_SET_DATA_TRANSFER_STATE: {
1237                 int value = DPM_STATUS_ERROR;
1238
1239                 __bt_service_get_parameters(in_param1, &value,
1240                                 sizeof(int));
1241
1242                 result = _bt_dpm_set_bluetooth_data_transfer_state(value);
1243
1244                 break;
1245         }
1246         case BT_DPM_GET_DATA_TRANSFER_STATE: {
1247                 int value = DPM_STATUS_ERROR;
1248
1249                 result = _bt_dpm_get_allow_bluetooth_data_transfer_state(&value);
1250                 g_array_append_vals(*out_param1, &value, sizeof(int));
1251                 break;
1252         }
1253 #endif
1254         case BT_RFCOMM_CLIENT_CONNECT: {
1255                 bluetooth_device_address_t address = { {0} };
1256                 char *input_string;
1257                 int connect_type;
1258
1259                 __bt_service_get_parameters(in_param1,
1260                                 &address, sizeof(bluetooth_device_address_t));
1261                 input_string = (char *)g_variant_get_data(in_param2);
1262                 __bt_service_get_parameters(in_param3, &connect_type, sizeof(int));
1263
1264                 if (connect_type == BT_RFCOMM_UUID)
1265                         result = _bt_rfcomm_connect_using_uuid(&address, input_string);
1266                 else
1267                         result = _bt_rfcomm_connect_using_channel(&address, input_string);
1268
1269                 if (result != BLUETOOTH_ERROR_NONE) {
1270                         bluetooth_rfcomm_connection_t conn_info;
1271
1272                         BT_ERR("BT_RFCOMM_CLIENT_CONNECT failed, send error");
1273                         memset(&conn_info, 0x00, sizeof(bluetooth_rfcomm_connection_t));
1274                         if (connect_type == BT_RFCOMM_UUID)
1275                                 g_strlcpy(conn_info.uuid, input_string, BLUETOOTH_UUID_STRING_MAX);
1276                         else
1277                                 g_strlcpy(conn_info.uuid, "not_used", BLUETOOTH_UUID_STRING_MAX);
1278
1279                         conn_info.device_role = RFCOMM_ROLE_CLIENT;
1280                         conn_info.socket_fd = -1;
1281                         g_array_append_vals(*out_param1, &conn_info,
1282                                         sizeof(bluetooth_rfcomm_connection_t));
1283                 } else {
1284                         char *addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
1285                         BT_ERR("BT_RFCOMM_CLIENT_CONNECT success, save context");
1286                         _bt_convert_addr_type_to_string(addr, address.addr);
1287                         sender = (char*)g_dbus_method_invocation_get_sender(context);
1288                         _bt_save_invocation_context(context, result, sender, function_name, addr);
1289                 }
1290                 break;
1291         }
1292         case BT_RFCOMM_SOCKET_DISCONNECT: {
1293                 /*
1294                  * Bluetooth RFCOMM socket disconnection will be done from bt-api, call to bt-service
1295                  * is only used for privilege check, so return BLUETOOTH_ERROR_NONE from here.
1296                  */
1297                 result = BLUETOOTH_ERROR_NONE;
1298                 break;
1299         }
1300         case BT_RFCOMM_SOCKET_WRITE: {
1301                 /*
1302                  * This call to bt-service is only used for privilege check, so return
1303                  * BLUETOOTH_ERROR_NONE from here.
1304                  */
1305                 result = BLUETOOTH_ERROR_NONE;
1306                 break;
1307         }
1308         case BT_RFCOMM_CREATE_SOCKET: {
1309                 /*
1310                  * This call to bt-service is only used for privilege check, so return
1311                  * BLUETOOTH_ERROR_NONE from here.
1312                  */
1313                 result = BLUETOOTH_ERROR_NONE;
1314                 break;
1315         }
1316         case BT_RFCOMM_LISTEN_AND_ACCEPT: {
1317                 char *uuid;
1318                 int socket_fd = -1;
1319
1320                 sender = (char *)g_dbus_method_invocation_get_sender(context);
1321                 uuid = (char *)g_variant_get_data(in_param1);
1322
1323                 result = _bt_rfcomm_socket_listen(sender, uuid, true);
1324                 if (result > 0) {
1325                         BT_ERR("BT_RFCOMM_LISTEN_AND_ACCEPT success, save context");
1326
1327                         result = BLUETOOTH_ERROR_NONE;
1328                         _bt_save_invocation_context(context,
1329                                         result, sender, function_name, NULL);
1330                 } else {
1331                         g_array_append_vals(*out_param1, &socket_fd, sizeof(int));
1332                 }
1333                 break;
1334         }
1335         case BT_RFCOMM_LISTEN: {
1336                 char *uuid;
1337                 int socket_fd = -1;
1338
1339                 sender = (char *)g_dbus_method_invocation_get_sender(context);
1340                 uuid = (char *)g_variant_get_data(in_param1);
1341
1342                 result = _bt_rfcomm_socket_listen(sender, uuid, false);
1343                 if (result > 0) {
1344                         BT_ERR("BT_RFCOMM_LISTEN success, save context");
1345
1346                         result = BLUETOOTH_ERROR_NONE;
1347                         _bt_save_invocation_context(context,
1348                                         result, sender, function_name, NULL);
1349                 } else {
1350                         g_array_append_vals(*out_param1, &socket_fd, sizeof(int));
1351                 }
1352                 break;
1353         }
1354         case BT_RFCOMM_ACCEPT_CONNECTION: {
1355                 char *address;
1356
1357                 address = (char *)g_variant_get_data(in_param1);
1358                 result = _bt_rfcomm_reply_conn_authorization(address, TRUE);
1359                 break;
1360         }
1361         case BT_RFCOMM_REJECT_CONNECTION: {
1362                 char *address;
1363
1364                 address = (char *)g_variant_get_data(in_param1);
1365                 result = _bt_rfcomm_reply_conn_authorization(address, FALSE);
1366                 break;
1367         }
1368         case BT_RFCOMM_REMOVE_SOCKET: {
1369                 /*
1370                  * This call to bt-service is only used for privilege check, so return
1371                  * BLUETOOTH_ERROR_NONE from here.
1372                  */
1373                 result = BLUETOOTH_ERROR_NONE;
1374                 break;
1375         }
1376         case BT_AUDIO_SELECT_ROLE: {
1377                 bluetooth_audio_role_t role;
1378
1379                 __bt_service_get_parameters(in_param1,
1380                                 &role, sizeof(bluetooth_audio_role_t));
1381
1382                 result = _bt_audio_select_role(role);
1383                 if (result == BLUETOOTH_ERROR_NONE) {
1384                         sender = (char*)g_dbus_method_invocation_get_sender(context);
1385                         _bt_save_invocation_context(context, result, sender,
1386                                         function_name, NULL);
1387                 }
1388                 break;
1389         }
1390         case BT_AV_CONNECT: {
1391                 bluetooth_device_address_t address = { {0} };
1392                 __bt_service_get_parameters(in_param1,
1393                                 &address, sizeof(bluetooth_device_address_t));
1394
1395                 result = _bt_audio_connect(BT_AUDIO_A2DP, &address);
1396
1397                 if (result != BLUETOOTH_ERROR_NONE) {
1398                         char addr[BT_ADDRESS_STRING_SIZE];
1399                         _bt_convert_addr_type_to_string(addr, address.addr);
1400                         g_array_append_vals(*out_param1, addr, BT_ADDRESS_STRING_SIZE);
1401                 } else {
1402                         char *addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
1403                         _bt_convert_addr_type_to_string(addr, address.addr);
1404                         sender = (char*)g_dbus_method_invocation_get_sender(context);
1405                         _bt_save_invocation_context(context, result, sender,
1406                                         function_name, (gpointer)addr);
1407                 }
1408                 break;
1409         }
1410         case BT_AUDIO_CONNECT: {
1411                 bluetooth_device_address_t address = { {0} };
1412                 __bt_service_get_parameters(in_param1,
1413                                 &address, sizeof(bluetooth_device_address_t));
1414
1415                 result = _bt_audio_connect(BT_AUDIO_ALL, &address);
1416
1417                 if (result != BLUETOOTH_ERROR_NONE) {
1418                         char addr[BT_ADDRESS_STRING_SIZE];
1419                         _bt_convert_addr_type_to_string(addr, address.addr);
1420                         g_array_append_vals(*out_param1, addr, BT_ADDRESS_STRING_SIZE);
1421                 } else {
1422                         char *addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
1423                         _bt_convert_addr_type_to_string(addr, address.addr);
1424                         sender = (char*)g_dbus_method_invocation_get_sender(context);
1425                         _bt_save_invocation_context(context, result, sender,
1426                                         function_name, (gpointer)addr);
1427                 }
1428                 break;
1429         }
1430         case BT_AUDIO_DISCONNECT: {
1431                 bluetooth_device_address_t address = { {0} };
1432                 __bt_service_get_parameters(in_param1,
1433                                 &address, sizeof(bluetooth_device_address_t));
1434
1435                 result = _bt_audio_disconnect(BT_AUDIO_ALL, &address);
1436
1437                 if (result != BLUETOOTH_ERROR_NONE) {
1438                         char addr[BT_ADDRESS_STRING_SIZE];
1439                         _bt_convert_addr_type_to_string(addr, address.addr);
1440                         g_array_append_vals(*out_param1, addr, BT_ADDRESS_STRING_SIZE);
1441                 } else {
1442                         char *addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
1443                         _bt_convert_addr_type_to_string(addr, address.addr);
1444                         sender = (char*)g_dbus_method_invocation_get_sender(context);
1445                         _bt_save_invocation_context(context, result, sender,
1446                                         function_name, (gpointer)addr);
1447                 }
1448                 break;
1449         }
1450         case BT_AV_DISCONNECT: {
1451                 bluetooth_device_address_t address = { {0} };
1452                 __bt_service_get_parameters(in_param1,
1453                                 &address, sizeof(bluetooth_device_address_t));
1454
1455                 result = _bt_audio_disconnect(BT_AUDIO_A2DP, &address);
1456
1457                 if (result != BLUETOOTH_ERROR_NONE) {
1458                         char addr[BT_ADDRESS_STRING_SIZE];
1459                         _bt_convert_addr_type_to_string(addr, address.addr);
1460                         g_array_append_vals(*out_param1, addr, BT_ADDRESS_STRING_SIZE);
1461                 } else {
1462                         char *addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
1463                         _bt_convert_addr_type_to_string(addr, address.addr);
1464                         sender = (char*)g_dbus_method_invocation_get_sender(context);
1465                         _bt_save_invocation_context(context, result, sender,
1466                                         function_name, (gpointer)addr);
1467                 }
1468                 break;
1469         }
1470         case BT_AG_CONNECT: {
1471                 bluetooth_device_address_t address = { {0} };
1472                 __bt_service_get_parameters(in_param1,
1473                                 &address, sizeof(bluetooth_device_address_t));
1474
1475                 result = _bt_audio_connect(BT_AUDIO_HSP, &address);
1476
1477                 if (result != BLUETOOTH_ERROR_NONE) {
1478                         char addr[BT_ADDRESS_STRING_SIZE];
1479                         _bt_convert_addr_type_to_string(addr, address.addr);
1480                         g_array_append_vals(*out_param1, addr, BT_ADDRESS_STRING_SIZE);
1481                 } else {
1482                         char *addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
1483                         _bt_convert_addr_type_to_string(addr, address.addr);
1484                         sender = (char*)g_dbus_method_invocation_get_sender(context);
1485                         _bt_save_invocation_context(context, result, sender,
1486                                         function_name, (gpointer)addr);
1487                 }
1488                 break;
1489         }
1490         case BT_AG_DISCONNECT: {
1491                 bluetooth_device_address_t address = { {0} };
1492
1493                 __bt_service_get_parameters(in_param1,
1494                                 &address, sizeof(bluetooth_device_address_t));
1495
1496                 result = _bt_audio_disconnect(BT_AUDIO_HSP, &address);
1497
1498                 if (result != BLUETOOTH_ERROR_NONE) {
1499                         char addr[BT_ADDRESS_STRING_SIZE];
1500                         _bt_convert_addr_type_to_string(addr, address.addr);
1501                         g_array_append_vals(*out_param1, addr, BT_ADDRESS_STRING_SIZE);
1502                 } else {
1503                         char *addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
1504                         _bt_convert_addr_type_to_string(addr, address.addr);
1505                         sender = (char*)g_dbus_method_invocation_get_sender(context);
1506                         _bt_save_invocation_context(context, result, sender,
1507                                         function_name, (gpointer)addr);
1508                 }
1509                 break;
1510         }
1511         case BT_AV_SOURCE_CONNECT: {
1512                 bluetooth_device_address_t address = { {0} };
1513
1514                 __bt_service_get_parameters(in_param1,
1515                                 &address, sizeof(bluetooth_device_address_t));
1516
1517                 result = _bt_audio_connect(BT_AUDIO_A2DP_SOURCE, &address);
1518                 if (result != BLUETOOTH_ERROR_NONE) {
1519                         char addr[BT_ADDRESS_STRING_SIZE];
1520                         _bt_convert_addr_type_to_string(addr, address.addr);
1521                         g_array_append_vals(*out_param1, addr, BT_ADDRESS_STRING_SIZE);
1522                 } else {
1523                         char *addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
1524                         _bt_convert_addr_type_to_string(addr, address.addr);
1525                         sender = (char*)g_dbus_method_invocation_get_sender(context);
1526                         _bt_save_invocation_context(context, result, sender,
1527                                         function_name, (gpointer)addr);
1528                 }
1529                 break;
1530         }
1531         case BT_AV_SOURCE_DISCONNECT: {
1532                 bluetooth_device_address_t address = { {0} };
1533
1534                 __bt_service_get_parameters(in_param1,
1535                                 &address, sizeof(bluetooth_device_address_t));
1536
1537                 result = _bt_audio_disconnect(BT_AUDIO_A2DP_SOURCE, &address);
1538                 if (result != BLUETOOTH_ERROR_NONE) {
1539                         char addr[BT_ADDRESS_STRING_SIZE];
1540                         _bt_convert_addr_type_to_string(addr, address.addr);
1541                         g_array_append_vals(*out_param1, addr, BT_ADDRESS_STRING_SIZE);
1542                 } else {
1543                         char *addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
1544                         _bt_convert_addr_type_to_string(addr, address.addr);
1545                         sender = (char*)g_dbus_method_invocation_get_sender(context);
1546                         _bt_save_invocation_context(context, result, sender,
1547                                         function_name, (gpointer)addr);
1548                 }
1549                 break;
1550         }
1551         case BT_AVRCP_TARGET_CONNECT: {
1552                 bluetooth_device_address_t address = { {0} };
1553
1554                 __bt_service_get_parameters(in_param1,
1555                                 &address, sizeof(bluetooth_device_address_t));
1556
1557                 result = _bt_audio_connect(BT_AVRCP_TARGET, &address);
1558                 if (result != BLUETOOTH_ERROR_NONE) {
1559                         char addr[BT_ADDRESS_STRING_SIZE];
1560                         _bt_convert_addr_type_to_string(addr, address.addr);
1561                         g_array_append_vals(*out_param1, addr, BT_ADDRESS_STRING_SIZE);
1562                 } else {
1563                         char *addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
1564                         _bt_convert_addr_type_to_string(addr, address.addr);
1565                         sender = (char*)g_dbus_method_invocation_get_sender(context);
1566                         _bt_save_invocation_context(context, result, sender,
1567                                         function_name, (gpointer)addr);
1568                 }
1569                 break;
1570         }
1571         case BT_AVRCP_TARGET_DISCONNECT: {
1572                 bluetooth_device_address_t address = { {0} };
1573
1574                 __bt_service_get_parameters(in_param1,
1575                                 &address, sizeof(bluetooth_device_address_t));
1576
1577                 result = _bt_audio_disconnect(BT_AVRCP_TARGET, &address);
1578                 if (result != BLUETOOTH_ERROR_NONE) {
1579                         char addr[BT_ADDRESS_STRING_SIZE];
1580                         _bt_convert_addr_type_to_string(addr, address.addr);
1581                         g_array_append_vals(*out_param1, addr, BT_ADDRESS_STRING_SIZE);
1582                 } else {
1583                         char *addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
1584                         _bt_convert_addr_type_to_string(addr, address.addr);
1585                         sender = (char*)g_dbus_method_invocation_get_sender(context);
1586                         _bt_save_invocation_context(context, result, sender,
1587                                         function_name, (gpointer)addr);
1588                 }
1589                 break;
1590         }
1591         case BT_AVRCP_CONTROL_CONNECT: {
1592                 bluetooth_device_address_t address = { {0} };
1593
1594                 __bt_service_get_parameters(in_param1,
1595                                 &address, sizeof(bluetooth_device_address_t));
1596
1597                 result = _bt_audio_connect(BT_AVRCP, &address);
1598                 if (result != BLUETOOTH_ERROR_NONE) {
1599                         char addr[BT_ADDRESS_STRING_SIZE];
1600                         _bt_convert_addr_type_to_string(addr, address.addr);
1601                         g_array_append_vals(*out_param1, addr, BT_ADDRESS_STRING_SIZE);
1602                 } else {
1603                         char *addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
1604                         _bt_convert_addr_type_to_string(addr, address.addr);
1605                         sender = (char*)g_dbus_method_invocation_get_sender(context);
1606                         _bt_save_invocation_context(context, result, sender,
1607                                         function_name, (gpointer)addr);
1608                 }
1609                 break;
1610         }
1611         case BT_AVRCP_CONTROL_DISCONNECT: {
1612                 bluetooth_device_address_t address = { {0} };
1613
1614                 __bt_service_get_parameters(in_param1,
1615                                 &address, sizeof(bluetooth_device_address_t));
1616
1617                 result = _bt_audio_disconnect(BT_AVRCP, &address);
1618                 if (result != BLUETOOTH_ERROR_NONE) {
1619                         char addr[BT_ADDRESS_STRING_SIZE];
1620                         _bt_convert_addr_type_to_string(addr, address.addr);
1621                         g_array_append_vals(*out_param1, addr, BT_ADDRESS_STRING_SIZE);
1622                 } else {
1623                         char *addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
1624                         _bt_convert_addr_type_to_string(addr, address.addr);
1625                         sender = (char*)g_dbus_method_invocation_get_sender(context);
1626                         _bt_save_invocation_context(context, result, sender,
1627                                         function_name, (gpointer)addr);
1628                 }
1629                 break;
1630         }
1631         case BT_AVRCP_HANDLE_CONTROL: {
1632                 int key_code;
1633                 __bt_service_get_parameters(in_param1, &key_code, sizeof(int));
1634                 result = _bt_avrcp_control_cmd(key_code);
1635                 break;
1636         }
1637         case BT_AVRCP_CONTROL_SET_PROPERTY: {
1638                 int type;
1639                 unsigned int value;
1640
1641                 __bt_service_get_parameters(in_param1,
1642                                 &type, sizeof(int));
1643                 __bt_service_get_parameters(in_param2,
1644                                 &value, sizeof(unsigned int));
1645
1646                 result = _bt_avrcp_control_set_property(type, value);
1647                 break;
1648         }
1649         case BT_AVRCP_TRANSPORT_SET_PROPERTY: {
1650                 int type;
1651                 unsigned int value;
1652                 BT_DBG("+");
1653
1654                 __bt_service_get_parameters(in_param1,
1655                                 &type, sizeof(int));
1656                 __bt_service_get_parameters(in_param2,
1657                                 &value, sizeof(unsigned int));
1658
1659                 result = _bt_avrcp_transport_set_property(type, value);
1660                 BT_DBG("-");
1661                 break;
1662         }
1663         case BT_AVRCP_CONTROL_GET_PROPERTY: {
1664                 int type;
1665
1666                 __bt_service_get_parameters(in_param1, &type, sizeof(int));
1667
1668                 result = _bt_avrcp_control_get_property(type);
1669                 /* Save invocation */
1670                 if (result == BLUETOOTH_ERROR_NONE) {
1671                         sender = (char*)g_dbus_method_invocation_get_sender(context);
1672                         _bt_save_invocation_context(context, result, sender,
1673                                         function_name, g_memdup(&type, sizeof(int)));
1674                 }
1675                 break;
1676         }
1677         case BT_AVRCP_GET_TRACK_INFO: {
1678                 result = _bt_avrcp_control_get_track_info();
1679                 /* Save invocation */
1680                 if (result == BLUETOOTH_ERROR_NONE) {
1681                         sender = (char*)g_dbus_method_invocation_get_sender(context);
1682                         _bt_save_invocation_context(context, result, sender,
1683                                         function_name, NULL);
1684                 }
1685                 break;
1686         }
1687         case BT_HDP_REGISTER_SINK_APP: {
1688                 unsigned short data_type;
1689                 bt_hdp_role_type_t role;
1690                 bt_hdp_qos_type_t channel_type;
1691                 int *app_id = g_new0(int, 1);
1692
1693                 __bt_service_get_parameters(in_param1,
1694                                 &data_type, sizeof(short));
1695                 __bt_service_get_parameters(in_param2,
1696                                 &role, sizeof(bt_hdp_role_type_t));
1697                 __bt_service_get_parameters(in_param3,
1698                                 &channel_type, sizeof(bt_hdp_qos_type_t));
1699                 sender = (char*)g_dbus_method_invocation_get_sender(context);
1700
1701                 result = _bt_hdp_app_register(role,
1702                                 channel_type, data_type, sender, app_id);
1703                 if (result != BLUETOOTH_ERROR_NONE) {
1704                         g_array_append_vals(*out_param1, &app_id, sizeof(app_id));
1705                         g_free(app_id);
1706                 } else {
1707                         _bt_save_invocation_context(context, result, sender,
1708                                         function_name, (gpointer)app_id);
1709                 }
1710                 break;
1711         }
1712         case BT_HDP_UNREGISTER_SINK_APP: {
1713                 char *app_handle;
1714                 int *app_id = g_new0(int, 1);
1715
1716                 app_handle = (char *)g_variant_get_data(in_param1);
1717                 sscanf(app_handle, "health_app_%d", app_id);
1718                 result = _bt_hdp_app_unregister(*app_id);
1719                 if (result != BLUETOOTH_ERROR_NONE) {
1720                         g_free(app_id);
1721                 } else {
1722                         sender = (char*)g_dbus_method_invocation_get_sender(context);
1723                         _bt_save_invocation_context(context, result, sender,
1724                                         function_name, (gpointer)app_id);
1725                 }
1726                 break;
1727         }
1728         case BT_HDP_CONNECT: {
1729                 int app_id = -1;
1730                 char *app_handle;
1731
1732                 bt_hdp_connected_t *conn_info = NULL;
1733
1734                 conn_info = g_malloc0(sizeof(bt_hdp_connected_t));
1735
1736                 app_handle = (char *)g_variant_get_data(in_param1);
1737                 conn_info->app_handle = app_handle;
1738                 sscanf(app_handle, "health_app_%d", &app_id);
1739
1740                 __bt_service_get_parameters(in_param2,
1741                                 &(conn_info->type), sizeof(bt_hdp_qos_type_t));
1742                 __bt_service_get_parameters(in_param3,
1743                                 &(conn_info->device_address),
1744                                 sizeof(bluetooth_device_address_t));
1745
1746                 result = _bt_hdp_connect(app_id, &(conn_info->device_address),
1747                                 conn_info->type, (int *)(&(conn_info->channel_id)));
1748                 if (result != BLUETOOTH_ERROR_NONE) {
1749                         g_array_append_vals(*out_param1, conn_info,
1750                                         sizeof(bt_hdp_connected_t));
1751                         g_free(conn_info);
1752                 } else {
1753                         sender = (char*)g_dbus_method_invocation_get_sender(context);
1754                         _bt_save_invocation_context(context, result, sender,
1755                                         function_name, (gpointer)conn_info);
1756                 }
1757                 break;
1758         }
1759         case BT_HDP_DISCONNECT: {
1760                 bt_hdp_disconnected_t *hdp_disconn_info = NULL;
1761
1762                 hdp_disconn_info = g_malloc0(sizeof(bt_hdp_disconnected_t));
1763
1764                 __bt_service_get_parameters(in_param1,
1765                                 &(hdp_disconn_info->channel_id), sizeof(int));
1766                 __bt_service_get_parameters(in_param2,
1767                                 &(hdp_disconn_info->device_address),
1768                                 sizeof(bluetooth_device_address_t));
1769
1770                 result = _bt_hdp_disconnect(hdp_disconn_info->channel_id);
1771                 if (result != BLUETOOTH_ERROR_NONE) {
1772                         g_array_append_vals(*out_param1, hdp_disconn_info,
1773                                         sizeof(bt_hdp_disconnected_t));
1774                         g_free(hdp_disconn_info);
1775                 } else {
1776                         sender = (char*)g_dbus_method_invocation_get_sender(context);
1777                         _bt_save_invocation_context(context, result, sender,
1778                                         function_name, (gpointer)hdp_disconn_info);
1779                 }
1780                 break;
1781         }
1782         case BT_HDP_GET_FD: {
1783                 int *channel_id = g_new0(int, 1);
1784
1785                 __bt_service_get_parameters(in_param1, channel_id, sizeof(int));
1786
1787                 result = _bt_hdp_get_fd(*channel_id);
1788                 if (result != BLUETOOTH_ERROR_NONE) {
1789                         g_free(channel_id);
1790                 } else {
1791                         sender = (char*)g_dbus_method_invocation_get_sender(context);
1792                         _bt_save_invocation_context(context, result, sender,
1793                                         function_name, (gpointer)channel_id);
1794                 }
1795                 break;
1796         }
1797         case BT_HDP_SEND_DATA: {
1798                 /*
1799                  * This call to bt-service is only used for privilege check, so return
1800                  * BLUETOOTH_ERROR_NONE from here.
1801                  */
1802                 result = BLUETOOTH_ERROR_NONE;
1803                 break;
1804         }
1805         case BT_OOB_READ_LOCAL_DATA: {  //208
1806                 bt_oob_data_t local_oob_data;
1807
1808                 memset(&local_oob_data, 0x00, sizeof(bt_oob_data_t));
1809                 result = _bt_oob_read_local_data(&local_oob_data);
1810
1811                 g_array_append_vals(*out_param1, &local_oob_data,
1812                                 sizeof(bt_oob_data_t));
1813
1814                 break;
1815         }
1816         case BT_OOB_ADD_REMOTE_DATA: {   //209
1817                 bluetooth_device_address_t address = { {0} };
1818                 unsigned short address_type;
1819                 bt_oob_data_t remote_oob_data;
1820
1821                 __bt_service_get_parameters(in_param1,
1822                                 &address, sizeof(bluetooth_device_address_t));
1823                 __bt_service_get_parameters(in_param2,
1824                                 &address_type, sizeof(unsigned short));
1825                 __bt_service_get_parameters(in_param3,
1826                                 &remote_oob_data, sizeof(bt_oob_data_t));
1827
1828                 result = _bt_oob_add_remote_data(&address, address_type, &remote_oob_data);
1829
1830                 break;
1831         }
1832         case BT_OOB_REMOVE_REMOTE_DATA: {       //210
1833                 bluetooth_device_address_t address = { {0} };
1834
1835                 __bt_service_get_parameters(in_param1,
1836                                 &address, sizeof(bluetooth_device_address_t));
1837
1838                 result = _bt_oob_remove_remote_data(&address);
1839
1840                 break;
1841         }
1842         case BT_AVRCP_SET_TRACK_INFO: {
1843                 media_metadata_t data;
1844                 media_metadata_attributes_t meta_data;
1845
1846                 memset(&data, 0x00, sizeof(media_metadata_t));
1847                 memset(&meta_data, 0x00, sizeof(media_metadata_attributes_t));
1848
1849                 __bt_service_get_parameters(in_param1,
1850                                 &data, sizeof(media_metadata_t));
1851
1852                 meta_data.title = g_strdup(data.title);
1853                 meta_data.artist = g_strdup(data.artist);
1854                 meta_data.album = g_strdup(data.album);
1855                 meta_data.genre = g_strdup(data.genre);
1856                 meta_data.total_tracks = data.total_tracks;
1857                 meta_data.number = data.number;
1858                 meta_data.duration = (int64_t) data.duration;
1859
1860                 result = _bt_avrcp_set_track_info(&meta_data);
1861
1862                 g_free((gpointer)meta_data.title);
1863                 g_free((gpointer)meta_data.artist);
1864                 g_free((gpointer)meta_data.album);
1865                 g_free((gpointer)meta_data.genre);
1866
1867                 break;
1868         }
1869         case BT_AVRCP_SET_PROPERTY: {
1870                 int type;
1871                 unsigned int value;
1872
1873                 sender = (char *)g_dbus_method_invocation_get_sender(context);
1874                 BT_INFO("Sender %s", sender);
1875
1876                 __bt_service_get_parameters(in_param1,
1877                                 &type, sizeof(int));
1878                 __bt_service_get_parameters(in_param2,
1879                                 &value, sizeof(unsigned int));
1880
1881                 if (value == STATUS_PLAYING) {
1882                         if (current_sender_playing)
1883                                 g_free(current_sender_playing);
1884                         current_sender_playing = g_strdup(sender);
1885                 }
1886                 if (g_strcmp0(sender, current_sender_playing) == 0 ||
1887                         current_sender_playing == NULL) {
1888                         BT_INFO("Current Player Status %d type %d", value, type);
1889                 } else {
1890                         BT_INFO("Current Player and this sender are different");
1891                         result = BLUETOOTH_ERROR_NONE;
1892                         break;
1893                 }
1894                 result = _bt_avrcp_set_property(type, value);
1895
1896                 break;
1897         }
1898         case BT_AVRCP_SET_PROPERTIES: {
1899                 media_player_settings_t properties;
1900
1901                 memset(&properties, 0x00, sizeof(media_player_settings_t));
1902                 __bt_service_get_parameters(in_param1,
1903                                 &properties, sizeof(media_player_settings_t));
1904
1905                 result = _bt_avrcp_set_properties(&properties);
1906
1907                 break;
1908         }
1909         case BT_SET_ADVERTISING_DATA: {
1910                 char *app = NULL;
1911                 int *adv_handle;
1912                 bluetooth_advertising_data_t adv = { {0} };
1913                 int length;
1914                 gboolean use_reserved_slot = FALSE;
1915
1916                 app = (char *)g_dbus_method_invocation_get_sender(context);
1917                 adv_handle = g_malloc0(sizeof(int));
1918
1919                 __bt_service_get_parameters(in_param1,
1920                                 adv_handle, sizeof(int));
1921                 __bt_service_get_parameters(in_param3,
1922                                 &length, sizeof(int));
1923                 __bt_service_get_parameters(in_param2,
1924                                 &adv, length);
1925                 __bt_service_get_parameters(in_param4,
1926                                 &use_reserved_slot, sizeof(gboolean));
1927                 result = _bt_set_advertising_data(app, *adv_handle,
1928                                 &adv, length, use_reserved_slot);
1929                 if (result != BLUETOOTH_ERROR_NONE) {
1930                         BT_ERR("Set Advertising data failed!!");
1931                         g_free(adv_handle);
1932                 } else {
1933                         _bt_save_invocation_context(context, result, app,
1934                                         function_name, (gpointer)adv_handle);
1935                 }
1936                 break;
1937         }
1938         case BT_SET_SCAN_RESPONSE_DATA: {
1939                 char *app = NULL;
1940                 int *adv_handle;
1941                 bluetooth_scan_resp_data_t rsp = { {0} };
1942                 int length;
1943                 gboolean use_reserved_slot = FALSE;
1944
1945                 app = (char *)g_dbus_method_invocation_get_sender(context);
1946                 adv_handle = g_malloc0(sizeof(int));
1947
1948                 __bt_service_get_parameters(in_param1,
1949                                 adv_handle, sizeof(int));
1950                 __bt_service_get_parameters(in_param3,
1951                                 &length, sizeof(int));
1952                 __bt_service_get_parameters(in_param2,
1953                                 &rsp, length);
1954                 __bt_service_get_parameters(in_param4,
1955                                 &use_reserved_slot, sizeof(gboolean));
1956
1957                 result = _bt_set_scan_response_data(app, *adv_handle,
1958                                 &rsp, length, use_reserved_slot);
1959
1960                 if (result != BLUETOOTH_ERROR_NONE) {
1961                         BT_ERR("Set Scan Response Data failed!!");
1962                         g_free(adv_handle);
1963                 } else {
1964                         _bt_save_invocation_context(context, result, app,
1965                                         function_name, (gpointer)adv_handle);
1966                 }
1967                 break;
1968         }
1969         case BT_SET_ADVERTISING: {
1970                 char *app = NULL;
1971                 int *adv_handle;
1972                 gboolean enable = FALSE;
1973                 gboolean use_reserved_slot = FALSE;
1974
1975                 adv_handle = g_malloc0(sizeof(int));
1976                 __bt_service_get_parameters(in_param1,
1977                                 adv_handle, sizeof(int));
1978                 __bt_service_get_parameters(in_param2,
1979                                 &enable, sizeof(gboolean));
1980                 __bt_service_get_parameters(in_param3,
1981                                 &use_reserved_slot, sizeof(gboolean));
1982
1983                 app = (char *)g_dbus_method_invocation_get_sender(context);
1984
1985                 result = _bt_set_advertising(app, *adv_handle,
1986                                 enable, use_reserved_slot);
1987                 if (result != BLUETOOTH_ERROR_NONE) {
1988                         BT_ERR("Start Advertising failed!!");
1989                         g_free(adv_handle);
1990                 } else {
1991                         _bt_save_invocation_context(context, result, app,
1992                                         function_name, (gpointer)adv_handle);
1993                 }
1994                 break;
1995         }
1996         case BT_SET_CUSTOM_ADVERTISING: {
1997                 char *app = NULL;
1998                 int *adv_handle;
1999                 gboolean enable = FALSE;
2000                 bluetooth_advertising_params_t adv_params;
2001                 gboolean use_reserved_slot = FALSE;
2002
2003                 app = (char *)g_dbus_method_invocation_get_sender(context);
2004                 adv_handle = g_malloc0(sizeof(int));
2005
2006                 __bt_service_get_parameters(in_param1, adv_handle,
2007                                 sizeof(int));
2008                 __bt_service_get_parameters(in_param2, &enable,
2009                                 sizeof(gboolean));
2010                 __bt_service_get_parameters(in_param3, &adv_params,
2011                                 sizeof(bluetooth_advertising_params_t));
2012                 __bt_service_get_parameters(in_param4, &use_reserved_slot,
2013                                 sizeof(gboolean));
2014
2015                 BT_DBG("bluetooth_advertising_params_t [%f %f %d %d]",
2016                                 adv_params.interval_min, adv_params.interval_max,
2017                                 adv_params.filter_policy, adv_params.type);
2018                 result = _bt_set_custom_advertising(app, *adv_handle,
2019                                 enable, &adv_params, use_reserved_slot);
2020                 if (result != BLUETOOTH_ERROR_NONE) {
2021                         BT_ERR("Start Custom Advertising failed!!");
2022                         g_free(adv_handle);
2023                 } else {
2024                         _bt_save_invocation_context(context, result, app,
2025                                         function_name, (gpointer)adv_handle);
2026                 }
2027                 break;
2028         }
2029         case BT_GET_SCAN_RESPONSE_DATA: {
2030                 bluetooth_scan_resp_data_t rsp = { {0} };
2031                 char *app = NULL;
2032                 int length = 0;
2033                 int adv_handle;
2034                 app = (char *)g_dbus_method_invocation_get_sender(context);
2035
2036                 __bt_service_get_parameters(in_param1, &adv_handle,
2037                                 sizeof(int));
2038
2039                 result = _bt_get_scan_response_data(app, adv_handle, &rsp, &length);
2040                 if (result == BLUETOOTH_ERROR_NONE)
2041                         g_array_append_vals(*out_param1, rsp.data, length);
2042
2043                 break;
2044         }
2045         case BT_GET_ADVERTISING_DATA: {
2046                 bluetooth_advertising_data_t adv = { {0} };
2047                 char *app = NULL;
2048                 int length = 0;
2049                 int adv_handle;
2050                 app = (char *)g_dbus_method_invocation_get_sender(context);
2051
2052                 __bt_service_get_parameters(in_param1, &adv_handle,
2053                                 sizeof(int));
2054
2055                 result = _bt_get_advertising_data(app, adv_handle, &adv, &length);
2056                 if (result == BLUETOOTH_ERROR_NONE)
2057                         g_array_append_vals(*out_param1, adv.data, length);
2058
2059                 break;
2060         }
2061         case BT_GATT_REGISTER_APPLICATION: {
2062                 BT_DBG("Register GATT application:Unhandled!!");
2063                 break;
2064         }
2065         case BT_GATT_SERVER_REGISTER: {
2066                 BT_DBG("GATT Server instance initialization");
2067                 char *app;
2068
2069                 app = (char *)g_dbus_method_invocation_get_sender(context);
2070                 BT_INFO("GATT Server Unique Name [%s]", app);
2071
2072                 /* No ADV handle: Set 0 */
2073                 result = _bt_register_server_instance(app, 0);
2074                 BT_INFO("GATT Server: Register Server result [%d]", result);
2075
2076                 if (result != BLUETOOTH_ERROR_NONE) {
2077                         BT_ERR("GATT Server registration failed!!");
2078                 } else {
2079                         _bt_save_invocation_context(context, result, app,
2080                                         function_name, NULL);
2081                 }
2082                 break;
2083         }
2084         case BT_GATT_SERVER_DEREGISTER: {
2085                 char *app;
2086                 app = (char*)g_dbus_method_invocation_get_sender(context);
2087
2088                 result = _bt_unregister_server_instance(app, 0/* Adv Handle*/);
2089                 break;
2090         }
2091         case BT_GATT_SERVER_ADD_SERVICE: {
2092                 BT_DBG("GATT Server Add Service");
2093                 int service_type;
2094                 int num_handles;
2095                 char *svc_uuid;
2096                 int instance_id;
2097                 char *app;
2098                 int *tmp_inst_id = NULL;
2099
2100                 app = (char *)g_dbus_method_invocation_get_sender(context);
2101
2102                 __bt_service_get_parameters(in_param1, &service_type,
2103                                 sizeof(int));
2104                 __bt_service_get_parameters(in_param2, &num_handles,
2105                                 sizeof(int));
2106                 svc_uuid = (char *)g_variant_get_data(in_param3);
2107                 __bt_service_get_parameters(in_param4, &instance_id,
2108                                 sizeof(int));
2109
2110                 BT_INFO("GATT Server Service UUID [%s]", svc_uuid);
2111                 result = _bt_gatt_server_add_service(app, service_type, num_handles, svc_uuid, instance_id);
2112                 if (result != BLUETOOTH_ERROR_NONE) {
2113                         BT_ERR("GATT Server Add Service failed!!");
2114                 } else {
2115                         tmp_inst_id = g_malloc0(sizeof(int));
2116                         *tmp_inst_id = instance_id;
2117                         BT_INFO("GATT Server: Save Instance ID in request Inst id [%d] request_id [%d]",
2118                                         *tmp_inst_id, instance_id);
2119                         _bt_save_invocation_context(context, result, app,
2120                                         function_name, (gpointer)tmp_inst_id);
2121                 }
2122                 break;
2123         }
2124         case BT_GATT_SERVER_ADD_CHARACTERISTIC: {
2125                 BT_DBG("GATT Server Add Characteristic");
2126                 char *char_uuid;
2127                 char *app;
2128                 int *tmp_inst_id = NULL;
2129                 bluetooth_gatt_server_attribute_params_t param;
2130                 memset(&param, 0, sizeof(bluetooth_gatt_server_attribute_params_t));
2131
2132                 app = (char*)g_dbus_method_invocation_get_sender(context);
2133
2134                 __bt_service_get_parameters(in_param1, &param,
2135                                 sizeof(bluetooth_gatt_server_attribute_params_t));
2136                 char_uuid = (char *)g_variant_get_data(in_param2);
2137
2138                 BT_INFO("GATT Server Characteristic UUID [%s]", char_uuid);
2139
2140                 result = _bt_gatt_server_add_characteristic(app, char_uuid, &param);
2141                 if (result != BLUETOOTH_ERROR_NONE) {
2142                         BT_ERR("GATT Server Add Service failed!!");
2143                 } else {
2144                         tmp_inst_id = g_malloc0(sizeof(int));
2145                         *tmp_inst_id = param.instance_id;
2146                         BT_INFO("GATT Server: Save Instance ID in request Inst id [%d] request_id [%d]",
2147                                         *tmp_inst_id, param.instance_id);
2148                         _bt_save_invocation_context(context, result, app,
2149                                         function_name, (gpointer)tmp_inst_id);
2150                 }
2151                 break;
2152         }
2153         case BT_GATT_SERVER_ADD_DESCRIPTOR: {
2154                 BT_DBG("GATT Server Add Descriptor");
2155                 char *desc_uuid;
2156                 int instance_id;
2157                 int service_handle;
2158                 bt_gatt_permission_t perm;
2159                 char *app;
2160                 int *tmp_inst_id = NULL;
2161                 memset(&perm, 0, sizeof(bt_gatt_permission_t));
2162
2163                 app = (char *)g_dbus_method_invocation_get_sender(context);
2164
2165                 __bt_service_get_parameters(in_param1, &service_handle,
2166                                 sizeof(int));
2167                 __bt_service_get_parameters(in_param2, &instance_id,
2168                                 sizeof(int));
2169                 desc_uuid = (char *)g_variant_get_data(in_param4);
2170                 __bt_service_get_parameters(in_param3, &perm,
2171                                 sizeof(bt_gatt_permission_t));
2172
2173                 BT_INFO("GATT Server Descriptor UUID [%s]", desc_uuid);
2174
2175                 result = _bt_gatt_server_add_descriptor(app, desc_uuid, &perm, service_handle, instance_id);
2176                 if (result != BLUETOOTH_ERROR_NONE) {
2177                         BT_ERR("GATT Server Add Service failed!!");
2178                 } else {
2179                         tmp_inst_id = g_malloc0(sizeof(int));
2180                         *tmp_inst_id = instance_id;
2181                         BT_INFO("GATT Server: Save Instance ID in request Inst id [%d] request_id [%d]",
2182                                         *tmp_inst_id, instance_id);
2183                         _bt_save_invocation_context(context, result, app,
2184                                         function_name, (gpointer)tmp_inst_id);
2185                 }
2186                 break;
2187         }
2188         case BT_GATT_SERVER_START_SERVICE: {
2189                 int service_handle;
2190                 int instance_id;
2191
2192                 char *app;
2193                 int *tmp_inst_id = NULL;
2194                 app = (char*)g_dbus_method_invocation_get_sender(context);
2195
2196                 __bt_service_get_parameters(in_param1, &service_handle,
2197                                 sizeof(int));
2198                 __bt_service_get_parameters(in_param2, &instance_id,
2199                                 sizeof(int));
2200
2201                 result = _bt_gatt_server_start_service(app, service_handle, instance_id);
2202
2203                 if (BLUETOOTH_ERROR_NONE == result) {
2204                         tmp_inst_id = g_malloc0(sizeof(int));
2205                         *tmp_inst_id = instance_id;
2206                         BT_INFO("GATT Server: Save Instance ID in request Inst id [%d] request_id [%d]",
2207                                         *tmp_inst_id, instance_id);
2208                         _bt_save_invocation_context(context, result, app,
2209                                         function_name, (gpointer)tmp_inst_id);
2210                 }
2211                 break;
2212         }
2213         case BT_GATT_SERVER_STOP_SERVICE: {
2214                 int service_handle;
2215                 int instance_id;
2216                 char *app;
2217                 int *tmp_inst_id = NULL;
2218                 app = (char*)g_dbus_method_invocation_get_sender(context);
2219
2220                 __bt_service_get_parameters(in_param1, &service_handle,
2221                                 sizeof(int));
2222                 __bt_service_get_parameters(in_param2, &instance_id,
2223                                 sizeof(int));
2224
2225                 result = _bt_gatt_server_stop_service(app, service_handle, instance_id);
2226
2227                 if (BLUETOOTH_ERROR_NONE == result) {
2228                         tmp_inst_id = g_malloc0(sizeof(int));
2229                         *tmp_inst_id = instance_id;
2230                         BT_INFO("GATT Server: Save Instance ID in request Inst id [%d] request_id [%d]",
2231                                         *tmp_inst_id, instance_id);
2232                         _bt_save_invocation_context(context, result, app,
2233                                         function_name, (gpointer)tmp_inst_id);
2234                 }
2235                 break;
2236         }
2237         case BT_GATT_SERVER_DELETE_SERVICE: {
2238                 int service_handle;
2239                 int instance_id;
2240                 int *tmp_inst_id = NULL;
2241                 char *app;
2242                 app = (char*)g_dbus_method_invocation_get_sender(context);
2243
2244                 __bt_service_get_parameters(in_param1, &service_handle,
2245                                 sizeof(int));
2246                 __bt_service_get_parameters(in_param2, &instance_id,
2247                                 sizeof(int));
2248
2249                 result = _bt_gatt_server_delete_service(app, service_handle, instance_id);
2250
2251                 if (BLUETOOTH_ERROR_NONE == result) {
2252                         tmp_inst_id = g_malloc0(sizeof(int));
2253                         *tmp_inst_id = instance_id;
2254                         BT_INFO("GATT Server: Save Instance ID in request Inst id [%d] request_id [%d]",
2255                                         *tmp_inst_id, instance_id);
2256                         _bt_save_invocation_context(context, result, app,
2257                                         function_name, (gpointer)tmp_inst_id);
2258                 }
2259                 break;
2260         }
2261         case BT_GATT_SERVER_SEND_RESPONSE: {
2262                 bluetooth_gatt_server_response_params_t param;
2263                 bluetooth_gatt_att_data_t data;
2264                 char *app;
2265
2266                 memset(&param, 0x00, sizeof(bluetooth_gatt_server_response_params_t));
2267                 memset(&data, 0x00, sizeof(bluetooth_gatt_att_data_t));
2268
2269                 app = (char*)g_dbus_method_invocation_get_sender(context);
2270
2271                 __bt_service_get_parameters(in_param1, &data,
2272                                 sizeof(bluetooth_gatt_att_data_t));
2273                 __bt_service_get_parameters(in_param2, &param,
2274                                 sizeof(bluetooth_gatt_server_response_params_t));
2275
2276                 result = _bt_gatt_server_send_response(app, &data, &param);
2277
2278                 break;
2279         }
2280         case BT_GATT_SERVER_ACQURE_WRITE_RESPONSE: {
2281
2282                 bluetooth_gatt_server_acquire_response_params_t param;
2283                 char *app;
2284                 GDBusMessage *msg;
2285                 msg = g_dbus_method_invocation_get_message(context);
2286                 GUnixFDList *fd_list;
2287                 int fd  = -1;;
2288                 int *fd_list_array;
2289                 int len;
2290
2291                 BT_ERR("sending acquire write  respose \n");
2292
2293                 fd_list = g_dbus_message_get_unix_fd_list(msg);
2294
2295                 memset(&param, 0x00, sizeof(bluetooth_gatt_server_acquire_response_params_t));
2296
2297                 app = (char*)g_dbus_method_invocation_get_sender(context);
2298
2299                 __bt_service_get_parameters(in_param1, &param,
2300                                 sizeof(bluetooth_gatt_server_acquire_response_params_t));
2301
2302                 BT_ERR("sending acquire write  respose sent \n  ");
2303
2304                 fd_list_array = (int *)g_unix_fd_list_peek_fds(fd_list, &len);
2305                 BT_INFO("Num fds in fd_list is : %d, fd_list[0]: %d", len, fd_list_array[0]);
2306                 fd = fd_list_array[0];
2307
2308                 param.fd = fd;
2309                 result = _bt_gatt_server_acquire_send_response(app, &param, fd_list);
2310
2311                 break;
2312         }
2313         case BT_GATT_SERVER_ACQUIRE_NOTIFY_RESPONSE: {
2314
2315                 bluetooth_gatt_server_acquire_response_params_t param;
2316                 char *app;
2317                 GDBusMessage *msg;
2318                 msg = g_dbus_method_invocation_get_message(context);
2319                 GUnixFDList *fd_list;
2320                 int fd  = -1;
2321                 int *fd_list_array;
2322                 int len;
2323
2324                 BT_ERR("sending acquire write  respose \n");
2325
2326                 fd_list = g_dbus_message_get_unix_fd_list(msg);
2327
2328                 memset(&param, 0x00, sizeof(bluetooth_gatt_server_acquire_response_params_t));
2329
2330                 app = (char*)g_dbus_method_invocation_get_sender(context);
2331
2332                 __bt_service_get_parameters(in_param1, &param,
2333                                 sizeof(bluetooth_gatt_server_acquire_response_params_t));
2334
2335                 BT_ERR("sending acquire write  respose sent \n  ");
2336
2337                 fd_list_array = (int *)g_unix_fd_list_peek_fds(fd_list, &len);
2338                 BT_INFO("Num fds in fd_list is : %d, fd_list[0]: %d", len, fd_list_array[0]);
2339                 fd = fd_list_array[0];
2340
2341                 param.fd = fd;
2342                 result = _bt_gatt_server_acquire_send_response(app, &param, fd_list);
2343
2344                 break;
2345         }
2346         case BT_GATT_SERVER_SEND_INDICATION: {
2347                 bluetooth_gatt_server_indication_params_t param;
2348                 bluetooth_gatt_att_data_t data;
2349                 bluetooth_device_address_t address;
2350
2351                 char *app;
2352                 app = (char*)g_dbus_method_invocation_get_sender(context);
2353
2354                 memset(&param, 0x00, sizeof(bluetooth_gatt_server_indication_params_t));
2355                 memset(&data, 0x00, sizeof(bluetooth_gatt_att_data_t));
2356                 memset(&address, 0x00, sizeof(bluetooth_device_address_t));
2357
2358                 __bt_service_get_parameters(in_param1, &data,
2359                                 sizeof(bluetooth_gatt_att_data_t));
2360                 __bt_service_get_parameters(in_param2, &param,
2361                                 sizeof(bluetooth_gatt_server_indication_params_t));
2362                 __bt_service_get_parameters(in_param3, &address,
2363                                 sizeof(bluetooth_device_address_t));
2364
2365                 result = _bt_gatt_server_send_indication(app, &address, &data, &param);
2366
2367                 break;
2368         }
2369         case BT_GATT_SERVER_UPDATE_VALUE: {
2370                 bluetooth_gatt_server_update_value_t param;
2371                 int instance_id;
2372                 char *app;
2373
2374                 memset(&param, 0x00, sizeof(bluetooth_gatt_server_update_value_t));
2375
2376                 app = (char*)g_dbus_method_invocation_get_sender(context);
2377
2378                 __bt_service_get_parameters(in_param1, &instance_id,
2379                                 sizeof(int));
2380                 __bt_service_get_parameters(in_param2, &param,
2381                                 sizeof(bluetooth_gatt_server_update_value_t));
2382
2383                 result = _bt_gatt_server_update_attribute_value(app, instance_id, &param);
2384                 break;
2385         }
2386         case BT_GET_ATT_MTU: {
2387                 bluetooth_device_address_t address = { {0} };
2388                 unsigned int mtu = 0;
2389
2390                 __bt_service_get_parameters(in_param1,
2391                                 &address, sizeof(bluetooth_device_address_t));
2392                 result = _bt_get_att_mtu(&address, &mtu);
2393                 BT_DBG("MTU: %d", mtu);
2394
2395                 if (result == BLUETOOTH_ERROR_NONE) {
2396                         g_array_append_vals(*out_param1, &mtu,
2397                                         sizeof(unsigned int));
2398                 }
2399                 break;
2400         }
2401 #ifdef TIZEN_GATT_CLIENT
2402         /* Local Async */
2403         case BT_GATT_CLIENT_REGISTER: {
2404                 bluetooth_device_address_t address = { {0} };
2405                 char *addr;
2406
2407                 sender = (char*)g_dbus_method_invocation_get_sender(context);
2408
2409                 __bt_service_get_parameters(in_param1,
2410                                 &address, sizeof(bluetooth_device_address_t));
2411
2412                 result = _bt_register_gatt_client_instance(sender, &address);
2413                 if (BLUETOOTH_ERROR_NONE == result) {
2414                         addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
2415
2416                         _bt_convert_addr_type_to_string(addr, address.addr);
2417                         BT_INFO("GATT Client: Save Invocation data GATT CLient Register app[%s] address [%s]", sender, addr);
2418
2419                         /* Save the informations to invocation */
2420                         _bt_save_invocation_context(context, result, sender,
2421                                         function_name, (gpointer)addr);
2422                 }
2423                 break;
2424         }
2425         /* Sync */
2426         case BT_GATT_CLIENT_UNREGISTER: {
2427                 int client_id;
2428
2429                 sender = (char*)g_dbus_method_invocation_get_sender(context);
2430                 __bt_service_get_parameters(in_param1,
2431                                 &client_id, sizeof(int));
2432
2433                 result = _bt_unregister_gatt_client_instance(sender, client_id);
2434                 break;
2435         }
2436
2437         /* Async: Remote Interaction  */
2438         case BT_GATT_ACQUIRE_WRITE: {
2439
2440                 int fd = -1;
2441                 int mtu = -1;
2442                 bluetooth_gatt_client_char_prop_info_t param;
2443
2444                 BT_INFO("GATT Client ACQUIRE WRITE recived");
2445
2446                 sender = (char*)g_dbus_method_invocation_get_sender(context);
2447
2448                 __bt_service_get_parameters(in_param1, &param,
2449                                         sizeof(bluetooth_gatt_client_char_prop_info_t));
2450
2451
2452                 result   = _bt_gatt_acquire_write(&param , &fd, &mtu);
2453
2454                 g_array_append_vals(*out_param1, &mtu, sizeof(int));
2455
2456                 if (BLUETOOTH_ERROR_NONE == result)
2457                         BT_INFO("GATT Client: Save Invocation data for characteristic props app[%s] fd[ %d]", sender, fd);
2458                 else {
2459                         BT_ERR("Gatt Client Acqure Write");
2460                         break;
2461                 }
2462
2463                 GUnixFDList *fd_list = NULL;
2464                 GError *error = NULL;
2465
2466                 /* Add socket fd to unix_fd_list */
2467                 fd_list = g_unix_fd_list_new();
2468                 g_unix_fd_list_append(fd_list, fd, &error);
2469                 g_assert_no_error(error);
2470
2471                 _bt_service_method_return_with_unix_fd_list(
2472                                 context, *out_param1, result, fd_list);
2473
2474                 close(fd);
2475                 g_object_unref(fd_list);
2476
2477                 break;
2478         }
2479         /* Async: Remote Interaction  */
2480         case BT_CONNECT_LE: {
2481                 bluetooth_device_address_t address = { {0} };
2482                 gboolean auto_connect;
2483                 char *addr;
2484                 int client_id;
2485
2486                 sender = (char*)g_dbus_method_invocation_get_sender(context);
2487
2488                 __bt_service_get_parameters(in_param1,
2489                                 &address, sizeof(bluetooth_device_address_t));
2490                 __bt_service_get_parameters(in_param2,
2491                                 &auto_connect, sizeof(gboolean));
2492                 __bt_service_get_parameters(in_param3,
2493                                 &client_id, sizeof(int));
2494
2495                 BT_INFO("GATT Client: client_id[%d]", client_id);
2496                 result = _bt_connect_le_device(&address, auto_connect, client_id);
2497                 if (BLUETOOTH_ERROR_NONE == result) {
2498
2499                         addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
2500                         BT_INFO("GATT Client: Save Invocation data Connect LE app[%s]", sender);
2501
2502                         _bt_convert_addr_type_to_string(addr, address.addr);
2503
2504                         /* Save the informations to invocation */
2505                         _bt_save_invocation_context(context, result, sender,
2506                                         function_name, (gpointer)addr);
2507                 } else {
2508                         BT_INFO("GATT Client: gatt connect failed");
2509                         g_array_append_vals(*out_param1, &address,
2510                                         sizeof(bluetooth_device_address_t));
2511                 }
2512                 break;
2513         }
2514         /* Async: Remote Interaction  */
2515         case BT_DISCONNECT_LE: {
2516                 bluetooth_device_address_t address = { {0} };
2517                 char *addr;
2518                 int client_id;
2519
2520                 sender = (char*)g_dbus_method_invocation_get_sender(context);
2521
2522                 __bt_service_get_parameters(in_param1,
2523                                 &address, sizeof(bluetooth_device_address_t));
2524                 __bt_service_get_parameters(in_param2,
2525                                 &client_id, sizeof(int));
2526
2527                 BT_INFO("GATT Disconnect using client Interface [%d]", client_id);
2528                 result = _bt_disconnect_le_device(&address, client_id);
2529                 if (BLUETOOTH_ERROR_NONE == result) {
2530                         addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
2531                         BT_INFO("GATT Client: Save Invocation data DisConnect LE app[%s]", sender);
2532
2533                         _bt_convert_addr_type_to_string(addr, address.addr);
2534
2535                         /* Save the informations to invocation */
2536                         _bt_save_invocation_context(context, result, sender,
2537                                         function_name, (gpointer)addr);
2538                 } else {
2539                         g_array_append_vals(*out_param1, &address,
2540                                         sizeof(bluetooth_device_address_t));
2541                 }
2542                 break;
2543         }
2544         case BT_GATT_GET_PRIMARY_SERVICES: {
2545                 char *addr;
2546
2547                 sender = (char*)g_dbus_method_invocation_get_sender(context);
2548                 bluetooth_device_address_t address = { {0} };
2549
2550                 __bt_service_get_parameters(in_param1, &address,
2551                                 sizeof(bluetooth_device_address_t));
2552
2553                 addr = g_malloc0(sizeof(char) * BT_ADDRESS_STRING_SIZE);
2554                 _bt_convert_addr_type_to_string(addr, address.addr);
2555
2556                 result = _bt_gatt_get_primary_services(addr);
2557                 if (BLUETOOTH_ERROR_NONE == result) {
2558                         BT_INFO("GATT Client: Save Remote GATT Server address addr [%s] app[%s]",
2559                                         addr, sender);
2560                         _bt_save_invocation_context(context, result, sender,
2561                                         function_name, (gpointer)addr);
2562                 } else
2563                         g_free(addr);
2564                 break;
2565         }
2566         /* Local Async */
2567         case BT_GATT_GET_SERVICE_PROPERTIES: {
2568                 bluetooth_gatt_client_svc_prop_info_t param;
2569
2570                 sender = (char*)g_dbus_method_invocation_get_sender(context);
2571                 memset(&param, 0x00, sizeof(bluetooth_gatt_client_svc_prop_info_t));
2572
2573                 __bt_service_get_parameters(in_param1, &param,
2574                                 sizeof(bluetooth_gatt_client_svc_prop_info_t));
2575
2576                 result = _bt_gatt_get_all_characteristic(&param);
2577                 if (BLUETOOTH_ERROR_NONE == result) {
2578                         BT_INFO("GATT Client: Save Invocation data for Service props app[%s]", sender);
2579
2580                         /* Save the informations to invocation */
2581                         _bt_save_invocation_context(context, result, sender,
2582                                         function_name,
2583                                         (gpointer)g_memdup(&param, sizeof(bluetooth_gatt_client_svc_prop_info_t)));
2584                 }
2585                 break;
2586         }
2587         case BT_GATT_GET_CHARACTERISTIC_PROPERTIES: {
2588                 bluetooth_gatt_client_char_prop_info_t param;
2589
2590                 sender = (char*)g_dbus_method_invocation_get_sender(context);
2591                 memset(&param, 0x00, sizeof(bluetooth_gatt_client_char_prop_info_t));
2592
2593                 __bt_service_get_parameters(in_param1, &param,
2594                                 sizeof(bluetooth_gatt_client_char_prop_info_t));
2595
2596                 result = _bt_gatt_get_all_characteristic_properties(&param);
2597                 if (BLUETOOTH_ERROR_NONE == result) {
2598                         BT_INFO("GATT Client: Save Invocation data for characteristic props app[%s]", sender);
2599
2600                         /* Save the informations to invocation */
2601                         _bt_save_invocation_context(context, result, sender,
2602                                         function_name,
2603                                         (gpointer)g_memdup(&param, sizeof(bluetooth_gatt_client_char_prop_info_t)));
2604                 }
2605                 break;
2606         }
2607         /* Async: Remote Interaction  */
2608         case BT_GATT_READ_CHARACTERISTIC: {
2609                 bluetooth_gatt_client_char_prop_info_t param;
2610
2611                 sender = (char*)g_dbus_method_invocation_get_sender(context);
2612                 memset(&param, 0x00, sizeof(bluetooth_gatt_client_char_prop_info_t));
2613
2614                 __bt_service_get_parameters(in_param1, &param,
2615                                 sizeof(bluetooth_gatt_client_char_prop_info_t));
2616
2617                 result = _bt_gatt_read_characteristic_value(&param);
2618                 if (BLUETOOTH_ERROR_NONE == result) {
2619                         BT_INFO("GATT Client: Save Invocation data for characteristic props app[%s]", sender);
2620
2621                         /* Save the informations to invocation */
2622                         _bt_save_invocation_context(context, result, sender,
2623                                         function_name,
2624                                         (gpointer)g_memdup(&param, sizeof(bluetooth_gatt_client_char_prop_info_t)));
2625                 }
2626                 break;
2627         }
2628         /* Async: Remote Interaction  */
2629         case BT_GATT_READ_DESCRIPTOR_VALUE: {
2630                 bluetooth_gatt_client_desc_prop_info_t param;
2631
2632                 sender = (char*)g_dbus_method_invocation_get_sender(context);
2633                 memset(&param, 0x00, sizeof(bluetooth_gatt_client_desc_prop_info_t));
2634
2635                 __bt_service_get_parameters(in_param1, &param,
2636                                 sizeof(bluetooth_gatt_client_desc_prop_info_t));
2637
2638                 result = _bt_gatt_read_descriptor_value(&param);
2639                 if (BLUETOOTH_ERROR_NONE == result) {
2640                         BT_INFO("GATT Client: Save Invocation data for Descriptor's props app[%s]", sender);
2641
2642                         /* Save the informations to invocation */
2643                         _bt_save_invocation_context(context, result, sender,
2644                                         function_name,
2645                                         (gpointer)g_memdup(&param, sizeof(bluetooth_gatt_client_desc_prop_info_t)));
2646                 }
2647                 break;
2648         }
2649         /* Async: Remote Interaction  */
2650         case BT_GATT_WRITE_CHARACTERISTIC_VALUE_BY_TYPE: {
2651                 bluetooth_gatt_client_char_prop_info_t param;
2652                 bluetooth_gatt_att_data_t data;
2653                 bluetooth_gatt_write_type_e write_type;
2654
2655                 sender = (char*)g_dbus_method_invocation_get_sender(context);
2656
2657                 memset(&data, 0x00, sizeof(bluetooth_gatt_att_data_t));
2658                 memset(&param, 0x00, sizeof(bluetooth_gatt_client_char_prop_info_t));
2659
2660                 __bt_service_get_parameters(in_param1, &param,
2661                                 sizeof(bluetooth_gatt_client_char_prop_info_t));
2662                 __bt_service_get_parameters(in_param2, &data,
2663                                 sizeof(bluetooth_gatt_att_data_t));
2664                 __bt_service_get_parameters(in_param3, &write_type,
2665                                 sizeof(bluetooth_gatt_write_type_e));
2666
2667                 result = _bt_gatt_write_characteristic_value_by_type(&param , &data, write_type);
2668                 if (BLUETOOTH_ERROR_NONE == result) {
2669                         BT_INFO("GATT Client: Save Invocation data for characteristic props app[%s]", sender);
2670
2671                         /* Save the informations to invocation */
2672                         _bt_save_invocation_context(context, result, sender,
2673                                         function_name,
2674                                         (gpointer)g_memdup(&param, sizeof(bluetooth_gatt_client_char_prop_info_t)));
2675                 }
2676                 break;
2677         }
2678         /* Async: Remote Interaction  */
2679         case BT_GATT_WRITE_DESCRIPTOR_VALUE: {
2680                 bluetooth_gatt_client_desc_prop_info_t param;
2681                 bluetooth_gatt_att_data_t data;
2682                 bluetooth_gatt_write_type_e write_type;
2683
2684                 sender = (char*)g_dbus_method_invocation_get_sender(context);
2685                 memset(&data, 0x00, sizeof(bluetooth_gatt_att_data_t));
2686                 memset(&param, 0x00, sizeof(bluetooth_gatt_client_desc_prop_info_t));
2687
2688                 __bt_service_get_parameters(in_param1, &param,
2689                                 sizeof(bluetooth_gatt_client_desc_prop_info_t));
2690                 __bt_service_get_parameters(in_param2, &data,
2691                                 sizeof(bluetooth_gatt_att_data_t));
2692                 __bt_service_get_parameters(in_param3, &write_type,
2693                                 sizeof(bluetooth_gatt_write_type_e));
2694
2695                 result = _bt_gatt_write_descriptor_value_by_type(&param, &data, write_type);
2696                 if (BLUETOOTH_ERROR_NONE == result) {
2697                         BT_INFO("GATT Client: Save Invocation data for descriptor props app[%s]", sender);
2698
2699                         /* Save the informations to invocation */
2700                         _bt_save_invocation_context(context, result, sender,
2701                                         function_name,
2702                                         (gpointer)g_memdup(&param, sizeof(bluetooth_gatt_client_desc_prop_info_t)));
2703                 }
2704                 break;
2705         }
2706         /* Local Async */
2707         case BT_GATT_WATCH_CHARACTERISTIC: {
2708                 bluetooth_gatt_client_char_prop_info_t param;
2709                 int client_id;
2710                 gboolean is_notify;
2711                 int fd = -1;
2712                 int mtu = 0;
2713                 gboolean is_indicate;
2714
2715
2716                 memset(&param, 0x00, sizeof(bluetooth_gatt_client_char_prop_info_t));
2717
2718                 sender = (char*)g_dbus_method_invocation_get_sender(context);
2719
2720                 __bt_service_get_parameters(in_param1, &param,
2721                                 sizeof(bluetooth_gatt_client_char_prop_info_t));
2722                 __bt_service_get_parameters(in_param2, &client_id,
2723                                 sizeof(int));
2724                 __bt_service_get_parameters(in_param3, &is_notify,
2725                                 sizeof(gboolean));
2726                 __bt_service_get_parameters(in_param4, &is_indicate,
2727                                 sizeof(gboolean));
2728
2729 #ifdef TIZEN_FEATURE_BT_GATT_CLIENT_FD_DISABLE
2730                 goto normal;
2731 #endif
2732
2733                 if (is_indicate == false) {
2734                         result   = _bt_gatt_acquire_notify(&param , &fd, &mtu);
2735                         if (BLUETOOTH_ERROR_NONE == result && fd > -1) {
2736                                 BT_INFO("GATT Client: Save Invocation data for characteristic props app[%s] fd[ %d]", sender, fd);
2737
2738                                 GUnixFDList *fd_list = NULL;
2739                                 GError *error = NULL;
2740
2741                                 g_array_append_vals(*out_param1, &mtu, sizeof(int));
2742                                 /* Add socket fd to unix_fd_list */
2743                                 fd_list = g_unix_fd_list_new();
2744                                 g_unix_fd_list_append(fd_list, fd, &error);
2745                                 g_assert_no_error(error);
2746                                 close(fd);
2747                                 _bt_service_method_return_with_unix_fd_list(
2748                                 context, *out_param1, result, fd_list);
2749
2750                                 g_object_unref(fd_list);
2751                         } else
2752                                 goto normal;
2753                 } else {
2754
2755 normal:
2756                         result = _bt_gatt_watch_characteristic(&param , client_id, is_notify);
2757                         if (BLUETOOTH_ERROR_NONE == result) {
2758                                 BT_INFO("GATT Client: Save Invocation data for characteristic props app[%s]", sender);
2759
2760                                 /* Save the informations to invocation */
2761                                 _bt_save_invocation_context(context, result, sender, function_name,
2762                                          (gpointer)g_memdup(&param, sizeof(bluetooth_gatt_client_char_prop_info_t)));
2763                         }
2764                 }
2765                 break;
2766         }
2767         case BT_GATT_WATCH_SERVICE_CHANGED_INDICATION: {
2768                 gboolean is_enabled;
2769                 bluetooth_device_address_t address;
2770
2771                 sender = (char*)g_dbus_method_invocation_get_sender(context);
2772
2773                 __bt_service_get_parameters(in_param1,
2774                                 &address, sizeof(bluetooth_device_address_t));
2775                 __bt_service_get_parameters(in_param2, &is_enabled,
2776                                 sizeof(gboolean));
2777                 result = _bt_gatt_watch_service_changed_indication(sender, &address, is_enabled);
2778                 BT_INFO("Service changed indication from app [%s]", sender);
2779
2780                 break;
2781         }
2782         case BT_LE_CONN_UPDATE: {
2783                 char *sender = NULL;
2784                 bluetooth_device_address_t local_address = { {0} };
2785                 bluetooth_le_connection_param_t parameters = {0};
2786
2787                 sender = (char *)g_dbus_method_invocation_get_sender(context);
2788
2789                 __bt_service_get_parameters(in_param1, &local_address,
2790                                 sizeof(bluetooth_device_address_t));
2791                 __bt_service_get_parameters(in_param2, &parameters,
2792                                 sizeof(bluetooth_le_connection_param_t));
2793
2794                 result = _bt_le_connection_update(sender,
2795                                         local_address.addr,
2796                                         parameters.interval_min,
2797                                         parameters.interval_max,
2798                                         parameters.latency,
2799                                         parameters.timeout);
2800                 break;
2801         }
2802 #endif
2803         case BT_START_LE_DISCOVERY: {
2804                 sender = (char *)g_dbus_method_invocation_get_sender(context);
2805                 result = _bt_start_le_scan(sender);
2806                 if (result == BLUETOOTH_ERROR_NONE) {
2807                         _bt_save_invocation_context(context, result, sender,
2808                                         function_name, NULL);
2809                 }
2810                 break;
2811         }
2812         case BT_STOP_LE_DISCOVERY: {
2813                 sender = (char *)g_dbus_method_invocation_get_sender(context);
2814                 result = _bt_stop_le_scan(sender);
2815                 if (result == BLUETOOTH_ERROR_NONE) {
2816                         _bt_save_invocation_context(context, result, sender,
2817                                         function_name, NULL);
2818                 }
2819                 break;
2820         }
2821         case BT_IS_LE_DISCOVERYING: {
2822                 gboolean le_discovering = FALSE;
2823
2824                 le_discovering = _bt_is_le_scanning();
2825                 g_array_append_vals(*out_param1,
2826                                 &le_discovering, sizeof(gboolean));
2827                 break;
2828         }
2829         case BT_SET_SCAN_PARAMETERS: {
2830                 bluetooth_le_scan_params_t scan_params;
2831
2832                 __bt_service_get_parameters(in_param1, &scan_params,
2833                                 sizeof(bluetooth_le_scan_params_t));
2834                 BT_DBG("bluetooth_le_scan_params_t [%f %f %d]",
2835                                 scan_params.interval, scan_params.window,
2836                                 scan_params.type);
2837                 result = _bt_set_scan_parameters(&scan_params);
2838                 break;
2839         }
2840 #ifdef TIZEN_FEATURE_BT_PAN_NAP
2841         case BT_NETWORK_ACTIVATE:
2842                 BT_DBG("BT_NETWORK_ACTIVATE Request recieved Request Handler ");
2843                 result = _bt_network_activate();
2844                 break;
2845         case BT_NETWORK_DEACTIVATE:
2846                 result = _bt_network_deactivate();
2847                 break;
2848         case BT_NETWORK_CONNECT: {
2849                 bluetooth_device_address_t address = { {0} };
2850                 int role;
2851
2852                 __bt_service_get_parameters(in_param1,
2853                                 &address, sizeof(bluetooth_device_address_t));
2854                 __bt_service_get_parameters(in_param2,
2855                                 &role, sizeof(int));
2856
2857                 result = _bt_network_connect(request_id, role, &address);
2858                 if (result != BLUETOOTH_ERROR_NONE) {
2859                         g_array_append_vals(*out_param1, &address,
2860                                         sizeof(bluetooth_device_address_t));
2861                 }
2862                 break;
2863         }
2864         case BT_NETWORK_DISCONNECT: {
2865                 bluetooth_device_address_t address = { {0} };
2866
2867                 __bt_service_get_parameters(in_param1,
2868                                 &address, sizeof(bluetooth_device_address_t));
2869
2870                 result = _bt_network_disconnect(request_id, &address);
2871                 if (result != BLUETOOTH_ERROR_NONE) {
2872                         g_array_append_vals(*out_param1, &address,
2873                                         sizeof(bluetooth_device_address_t));
2874                 }
2875                 break;
2876         }
2877         case BT_NETWORK_SERVER_DISCONNECT: {
2878                 bluetooth_device_address_t address = { {0} };
2879
2880                 __bt_service_get_parameters(in_param1,
2881                                 &address, sizeof(bluetooth_device_address_t));
2882
2883                 result = _bt_network_server_disconnect(request_id, &address);
2884                 if (result != BLUETOOTH_ERROR_NONE) {
2885                         g_array_append_vals(*out_param1, &address,
2886                                         sizeof(bluetooth_device_address_t));
2887                 }
2888                 break;
2889         }
2890
2891 #endif
2892 #ifdef TIZEN_FEATURE_BT_IPSP
2893         case BT_LE_IPSP_INIT:
2894                 result = _bt_initialize_ipsp();
2895                 break;
2896         case BT_LE_IPSP_DEINIT:
2897                 result = _bt_deinitialize_ipsp();
2898                 break;
2899         case BT_LE_IPSP_CONNECT: {
2900                 bluetooth_device_address_t address = { {0} };
2901                 __bt_service_get_parameters(in_param1, &address,
2902                                 sizeof(bluetooth_device_address_t));
2903                 result = _bt_connect_le_ipsp_device(&address);
2904                 break;
2905         }
2906         case BT_LE_IPSP_DISCONNECT: {
2907                 bluetooth_device_address_t address = { {0} };
2908                 __bt_service_get_parameters(in_param1, &address,
2909                                 sizeof(bluetooth_device_address_t));
2910                 result = _bt_disconnect_le_ipsp_device(&address);
2911                 break;
2912         }
2913 #endif
2914         case BT_IS_ADVERTISING: {
2915                 gboolean advertising = FALSE;
2916                 advertising = _bt_is_advertising();
2917                 g_array_append_vals(*out_param1, &advertising,
2918                                 sizeof(gboolean));
2919                 break;
2920         }
2921         case BT_IS_LE_2M_PHY_SUPPORTED: {
2922                 gboolean is_2m_phy_supported = FALSE;
2923
2924                 is_2m_phy_supported = _bt_is_le_2m_phy_supported();
2925                 g_array_append_vals(*out_param1, &is_2m_phy_supported, sizeof(gboolean));
2926                 break;
2927         }
2928         case BT_IS_LE_CODED_PHY_SUPPORTED: {
2929                 gboolean is_coded_phy_supported = FALSE;
2930
2931                 is_coded_phy_supported = _bt_is_le_coded_phy_supported();
2932                 g_array_append_vals(*out_param1, &is_coded_phy_supported, sizeof(gboolean));
2933                 break;
2934         }
2935         default:
2936                 BT_INFO("UnSupported function [%d]", function_name);
2937                 result = BLUETOOTH_ERROR_NOT_SUPPORT;
2938                 break;
2939         }
2940
2941         return result;
2942 }
2943 #ifdef TIZEN_FEATURE_BT_OBEX
2944 /* Function definitions*/
2945 static void __bt_fill_garray_from_variant(GVariant *var, GArray *param)
2946 {
2947         char *data;
2948         int size;
2949
2950         size = g_variant_get_size(var);
2951         if (size > 0) {
2952                 data = (char *)g_variant_get_data(var);
2953                 if (data)
2954                         param = g_array_append_vals(param, data, size);
2955
2956         }
2957 }
2958 #endif
2959
2960 int __bt_obexd_request(int function_name,
2961                 int request_type,
2962                 int request_id,
2963                 GDBusMethodInvocation *context,
2964                 GVariant *in_param1,
2965                 GVariant *in_param2,
2966                 GVariant *in_param3,
2967                 GVariant *in_param4,
2968                 GArray **out_param1)
2969 {
2970         BT_DBG("+");
2971
2972         int result = BLUETOOTH_ERROR_NONE;
2973
2974         BT_DBG("function_name : %x", function_name);
2975
2976         switch (function_name) {
2977         case BT_OPP_PUSH_FILES: {
2978                 BT_DBG("BT_OPP_PUSH_FILES");
2979                 int i;
2980                 bluetooth_device_address_t address = { {0} };
2981                 bt_file_path_t *path;
2982                 char **file_path;
2983                 int file_count;
2984                 GArray *param2;
2985
2986                 __bt_service_get_parameters(in_param1, &address,
2987                                 sizeof(bluetooth_device_address_t));
2988                 __bt_service_get_parameters(in_param3, &file_count,
2989                                 sizeof(int));
2990
2991                 file_path = g_new0(char *, file_count + 1);
2992
2993                 param2 = g_array_new(TRUE, TRUE, sizeof(gchar));
2994                 __bt_fill_garray_from_variant(in_param2, param2);
2995
2996                 for (i = 0; i < file_count; i++) {
2997                         path = &g_array_index(param2, bt_file_path_t, i);
2998                         file_path[i] = g_strdup(path->path);
2999                 }
3000                 BT_DBG("_bt_opp_client_push_files");
3001                 result = _bt_opp_client_push_files(request_id, context,
3002                                                 &address, file_path,
3003                                                 file_count);
3004
3005                 for (i = 0; i < file_count; i++)
3006                         g_free(file_path[i]);
3007
3008                 g_free(file_path);
3009                 g_array_free(param2, TRUE);
3010
3011                 break;
3012         }
3013         case BT_OPP_CANCEL_PUSH: {
3014                 result = _bt_opp_client_cancel_push();
3015
3016                 break;
3017         }
3018         case BT_OPP_IS_PUSHING_FILES: {
3019                 gboolean is_sending = FALSE;
3020
3021                 result = _bt_opp_client_is_sending(&is_sending);
3022
3023                 g_array_append_vals(*out_param1, &is_sending,
3024                                 sizeof(gboolean));
3025                 break;
3026         }
3027         case BT_OPP_GET_TRANSFER_PROGRESS: {
3028                 int direction;
3029                 int transfer_id;
3030                 guint8 progress = 0;
3031
3032                 __bt_service_get_parameters(in_param1, &direction,
3033                                 sizeof(int));
3034                 __bt_service_get_parameters(in_param2, &transfer_id,
3035                                 sizeof(int));
3036                 if (direction)
3037                         result = _bt_opp_get_client_progress(&progress);
3038                 else
3039                         result = _bt_opp_get_server_progress(transfer_id, &progress);
3040
3041                 g_array_append_vals(*out_param1, &progress,
3042                                 sizeof(guint8));
3043
3044                 break;
3045         }
3046
3047         case BT_MAP_CREATE_SESSION: {
3048                 BT_DBG("BT_MAP_CREATE_SESSION");
3049                 char *address = (char *)g_variant_get_data(in_param1);
3050                 char *session_id = NULL;
3051                 result = _bt_create_session_sync(address, &session_id);
3052                 if (result == BLUETOOTH_ERROR_NONE)
3053                         g_array_append_vals(*out_param1, session_id, strlen(session_id)+1);
3054                 break;
3055         }
3056
3057         case BT_MAP_DESTROY_SESSION: {
3058                 BT_DBG("BT_MAP_DESTROY_SESSION");
3059                 char* session_id = (char *)g_variant_get_data(in_param1);
3060                 result = _bt_destroy_session_sync(session_id);
3061                 if (result == BLUETOOTH_ERROR_NONE)
3062                         BT_DBG("successfully destroyed session");
3063                 break;
3064         }
3065
3066         case BT_MAP_SET_FOLDER: {
3067                 BT_DBG("BT_MAP_SET_FOLDER");
3068                 char *session_id = (char *)g_variant_get_data(in_param1);
3069                 char *name = (char *)g_variant_get_data(in_param2);
3070                 result = _bt_map_client_set_folder(session_id, name);
3071                 break;
3072         }
3073
3074         case BT_MAP_LIST_FOLDERS: {
3075                 BT_DBG("BT_MAP_LIST_FOLDERS");
3076
3077                 char* session_id = (char *)g_variant_get_data(in_param1);
3078                 char* filter_serialized = (char*)g_variant_get_data(in_param2);
3079
3080                 result = _bt_map_client_list_folders(request_id, context, session_id, filter_serialized);
3081                 if (result == BLUETOOTH_ERROR_NONE)
3082                         BT_DBG("_bt_map_client_list_folders succeed");
3083
3084                 break;
3085         }
3086
3087         case BT_MAP_LIST_FILTER_FIELDS: {
3088                 BT_DBG("BT_MAP_LIST_FILTER_FIELDS");
3089
3090                 char* session_id = (char *)g_variant_get_data(in_param1);
3091
3092                 result = _bt_map_client_list_filter_fields(request_id, context, session_id);
3093                 if (result == BLUETOOTH_ERROR_NONE)
3094                         BT_DBG("_bt_map_client_list_filter_fields succeed");
3095
3096                 break;
3097         }
3098
3099         case BT_MAP_LIST_MESSAGES: {
3100                 BT_DBG("BT_MAP_LIST_MESSAGES");
3101
3102                 char* session_id = (char*)g_variant_get_data(in_param1);
3103                 char* folder = (char*)g_variant_get_data(in_param2);
3104                 char* filter_serialized = (char*)g_variant_get_data(in_param3);
3105
3106                 result = _bt_map_client_list_messages(request_id, context, session_id, folder, filter_serialized);
3107                 if (result == BLUETOOTH_ERROR_NONE)
3108                         BT_DBG("_bt_map_client_list_messages succeed");
3109                 else
3110                         BT_DBG("_bt_map_client_list_messages failed");
3111
3112                 break;
3113         }
3114
3115         case BT_MAP_UPDATE_INBOX: {
3116                 BT_DBG("BT_MAP_UPDATE_INBOX");
3117                 char* session_id = (char *)g_variant_get_data(in_param1);
3118                 result = _bt_map_client_update_inbox(session_id);
3119                 break;
3120         }
3121
3122         case BT_MAP_PUSH_MESSAGE: {
3123                 BT_DBG("BT_MAP_PUSH_MESSAGE");
3124
3125                 char* session_id = (char *)g_variant_get_data(in_param1);
3126                 char* source_file = (char *)g_variant_get_data(in_param2);
3127                 char* folder = (char *)g_variant_get_data(in_param3);
3128                 char* args_serialized = (char *)g_variant_get_data(in_param4);
3129
3130                 result = _bt_map_client_push_message(
3131                                 request_id, context, session_id, source_file, folder, args_serialized);
3132                 if (result == BLUETOOTH_ERROR_NONE)
3133                         BT_DBG("_bt_map_client_push_message succeed");
3134                 else
3135                         BT_ERR("_bt_map_client_push_message failed");
3136
3137                 break;
3138         }
3139
3140         case BT_MAP_GET_MESSAGE: {
3141                 BT_DBG("BT_MAP_GET_MESSAGE");
3142                 // TODO session currently is not used, but should be valid
3143                 //char* session_id = (char *)g_variant_get_data(in_param1);
3144                 char* message_object = (char *)g_variant_get_data(in_param2);
3145                 char* target_file = (char *)g_variant_get_data(in_param3);
3146                 bool attachment = false;
3147                 __bt_service_get_parameters(in_param4, &attachment, sizeof(bool));
3148
3149                 result = _bt_map_client_get_message(request_id, context, message_object,
3150                                 target_file, attachment);
3151                 if (result == BLUETOOTH_ERROR_NONE)
3152                         BT_DBG("_bt_map_client_get_message succeed");
3153
3154                 break;
3155         }
3156
3157         case BT_OBEX_SERVER_ALLOCATE: {
3158                 int app_pid;
3159                 gboolean is_native;
3160                 char *path;
3161                 char *sender;
3162
3163                 sender = (char *)g_dbus_method_invocation_get_sender(context);
3164
3165                 path = (char *)g_variant_get_data(in_param1);
3166                 __bt_service_get_parameters(in_param2, &is_native,
3167                                 sizeof(gboolean));
3168                 __bt_service_get_parameters(in_param3, &app_pid,
3169                                 sizeof(int));
3170
3171                 result = _bt_obex_server_allocate(sender,
3172                                 path, app_pid, is_native);
3173
3174                 break;
3175         }
3176         case BT_OBEX_SERVER_DEALLOCATE: {
3177                 int app_pid;
3178                 gboolean is_native;
3179
3180                 __bt_service_get_parameters(in_param1, &is_native,
3181                                 sizeof(gboolean));
3182                 __bt_service_get_parameters(in_param2, &app_pid,
3183                                 sizeof(int));
3184
3185                 result = _bt_obex_server_deallocate(app_pid, is_native);
3186                 break;
3187         }
3188         case BT_OBEX_SERVER_IS_ACTIVATED: {
3189                 gboolean is_activated = FALSE;
3190
3191                 result = _bt_obex_server_is_activated(&is_activated);
3192
3193                 g_array_append_vals(*out_param1, &is_activated,
3194                                 sizeof(gboolean));
3195
3196                 break;
3197         }
3198         case BT_OBEX_SERVER_ACCEPT_CONNECTION: {
3199                 result = _bt_obex_server_accept_connection(request_id);
3200
3201                 break;
3202         }
3203         case BT_OBEX_SERVER_REJECT_CONNECTION: {
3204                 result = _bt_obex_server_reject_connection();
3205
3206                 break;
3207         }
3208         case BT_OBEX_SERVER_ACCEPT_FILE: {
3209                 char *file_name;
3210
3211                 file_name = (char *)g_variant_get_data(in_param1);
3212
3213                 result = _bt_obex_server_accept_authorize(file_name, TRUE);
3214
3215                 break;
3216         }
3217         case BT_OBEX_SERVER_REJECT_FILE: {
3218                 result = _bt_obex_server_reject_authorize();
3219
3220                 break;
3221         }
3222         case BT_OBEX_SERVER_SET_PATH: {
3223                 gboolean is_native;
3224                 char *destination_path;
3225
3226                 destination_path = (char *)g_variant_get_data(in_param1);
3227                 __bt_service_get_parameters(in_param2, &is_native,
3228                                 sizeof(gboolean));
3229
3230                 result = _bt_obex_server_set_destination_path(destination_path,
3231                                                         is_native);
3232
3233                 break;
3234         }
3235         case BT_OBEX_SERVER_SET_ROOT: {
3236                 char *root;
3237
3238                 root = (char *)g_variant_get_data(in_param1);
3239
3240                 result = _bt_obex_server_set_root(root);
3241
3242                 break;
3243         }
3244         case BT_OBEX_SERVER_CANCEL_TRANSFER: {
3245                 int transfer_id;
3246
3247                 __bt_service_get_parameters(in_param1, &transfer_id,
3248                                 sizeof(int));
3249
3250                 result = _bt_obex_server_cancel_transfer(transfer_id);
3251
3252                 break;
3253         }
3254         case BT_OBEX_SERVER_CANCEL_ALL_TRANSFERS: {
3255                 result = _bt_obex_server_cancel_all_transfers();
3256
3257                 break;
3258         }
3259         case BT_OBEX_SERVER_IS_RECEIVING: {
3260                 gboolean is_receiving = FALSE;
3261
3262                 result = _bt_obex_server_is_receiving(&is_receiving);
3263
3264                 g_array_append_vals(*out_param1, &is_receiving,
3265                                 sizeof(gboolean));
3266                 break;
3267         }
3268         case BT_PBAP_CONNECT: {
3269                 bluetooth_device_address_t address = { {0} };
3270
3271                 __bt_service_get_parameters(in_param1, &address,
3272                                 sizeof(bluetooth_device_address_t));
3273
3274                 result = _bt_pbap_connect(&address);
3275                 break;
3276         }
3277         case BT_PBAP_DISCONNECT: {
3278                 bluetooth_device_address_t address = { {0} };
3279
3280                 __bt_service_get_parameters(in_param1, &address,
3281                                 sizeof(bluetooth_device_address_t));
3282
3283                 result = _bt_pbap_disconnect(&address);
3284                 break;
3285         }
3286         case BT_PBAP_GET_PHONEBOOK_SIZE: {
3287                 bluetooth_device_address_t address = { {0} };
3288                 bt_pbap_folder_t folder = { 0, };
3289
3290                 __bt_service_get_parameters(in_param1, &address,
3291                                 sizeof(bluetooth_device_address_t));
3292                 __bt_service_get_parameters(in_param2, &folder,
3293                                 sizeof(bt_pbap_folder_t));
3294
3295                 result = _bt_pbap_get_phonebook_size(&address,
3296                                 folder.addressbook, folder.folder_type);
3297                 break;
3298         }
3299         case BT_PBAP_GET_PHONEBOOK: {
3300                 bluetooth_device_address_t address = { {0} };
3301                 bt_pbap_folder_t folder = { 0, };
3302                 bt_pbap_pull_parameters_t app_param = { 0, };
3303
3304                 __bt_service_get_parameters(in_param1, &address,
3305                                 sizeof(bluetooth_device_address_t));
3306                 __bt_service_get_parameters(in_param2, &folder,
3307                                 sizeof(bt_pbap_folder_t));
3308                 __bt_service_get_parameters(in_param3, &app_param,
3309                                 sizeof(bt_pbap_pull_parameters_t));
3310
3311                 result = _bt_pbap_get_phonebook(&address, folder.addressbook,
3312                                 folder.folder_type, &app_param);
3313                 break;
3314         }
3315         case BT_PBAP_GET_LIST: {
3316                 bluetooth_device_address_t address = { {0} };
3317                 bt_pbap_folder_t folder = { 0, };
3318                 bt_pbap_list_parameters_t app_param = { 0, };
3319
3320                 __bt_service_get_parameters(in_param1, &address,
3321                                 sizeof(bluetooth_device_address_t));
3322                 __bt_service_get_parameters(in_param2, &folder,
3323                                 sizeof(bt_pbap_folder_t));
3324                 __bt_service_get_parameters(in_param3, &app_param,
3325                                 sizeof(bt_pbap_list_parameters_t));
3326
3327                 result = _bt_pbap_get_list(&address, folder.addressbook,
3328                                 folder.folder_type, &app_param);
3329                 break;
3330         }
3331         case BT_PBAP_PULL_VCARD: {
3332                 bluetooth_device_address_t address = { {0} };
3333                 bt_pbap_folder_t folder = { 0, };
3334                 bt_pbap_pull_vcard_parameters_t app_param = { 0, };
3335
3336                 __bt_service_get_parameters(in_param1, &address,
3337                                 sizeof(bluetooth_device_address_t));
3338                 __bt_service_get_parameters(in_param2, &folder,
3339                                 sizeof(bt_pbap_folder_t));
3340                 __bt_service_get_parameters(in_param3, &app_param,
3341                                 sizeof(bt_pbap_pull_vcard_parameters_t));
3342
3343                 result = _bt_pbap_pull_vcard(&address, folder.addressbook,
3344                                 folder.folder_type, &app_param);
3345                 break;
3346         }
3347         case BT_PBAP_PHONEBOOK_SEARCH: {
3348                 bluetooth_device_address_t address = { {0} };
3349                 bt_pbap_folder_t folder = { 0, };
3350                 bt_pbap_search_parameters_t app_param = { 0, };
3351
3352                 __bt_service_get_parameters(in_param1, &address,
3353                                 sizeof(bluetooth_device_address_t));
3354                 __bt_service_get_parameters(in_param2, &folder,
3355                                 sizeof(bt_pbap_folder_t));
3356                 __bt_service_get_parameters(in_param3, &app_param,
3357                                 sizeof(bt_pbap_search_parameters_t));
3358
3359                 result = _bt_pbap_phonebook_search(&address, folder.addressbook,
3360                                 folder.folder_type, &app_param);
3361                 break;
3362         }
3363
3364         default:
3365                 BT_ERR("Unknown function!");
3366                 result = BLUETOOTH_ERROR_INTERNAL;
3367                 break;
3368         }
3369
3370         FN_END;
3371
3372         return result;
3373 }
3374
3375 int __bt_agent_request(int function_name,
3376                 int request_type,
3377                 int request_id,
3378                 GDBusMethodInvocation *context,
3379                 GVariant *in_param1,
3380                 GVariant *in_param2,
3381                 GVariant *in_param3,
3382                 GVariant *in_param4,
3383                 GArray **out_param1)
3384 {
3385         int result;
3386         switch (function_name) {
3387         case BT_SET_AUTHORIZATION: {
3388                 int type;
3389                 char *uuid;
3390                 char *path;
3391                 int fd;
3392
3393                 __bt_service_get_parameters(in_param1, &type, sizeof(int));
3394                 uuid = (char *)g_variant_get_data(in_param2);
3395                 path = (char *)g_variant_get_data(in_param3);
3396                 __bt_service_get_parameters(in_param4, &fd, sizeof(int));
3397
3398                 result = _bt_register_osp_server_in_agent(type, uuid, path, fd);
3399                 break;
3400         }
3401         case BT_UNSET_AUTHORIZATION: {
3402                 int type;
3403                 char *uuid;
3404
3405                 __bt_service_get_parameters(in_param1, &type, sizeof(int));
3406                 uuid = (char *)g_variant_get_data(in_param2);
3407
3408                 result = _bt_unregister_osp_server_in_agent(type, uuid);
3409                 break;
3410         }
3411         default:
3412                 BT_ERR("Unknown function!");
3413                 result = BLUETOOTH_ERROR_INTERNAL;
3414                 break;
3415         }
3416
3417         return result;
3418 }
3419
3420 int __bt_core_request(int function_name,
3421                 int request_type,
3422                 int request_id,
3423                 GDBusMethodInvocation *context,
3424                 GVariant *in_param1)
3425 {
3426         int result;
3427
3428         switch (function_name) {
3429         case BT_ENABLE_ADAPTER:
3430         {
3431                 bt_status_t status;
3432
3433                 status = _bt_adapter_get_status();
3434
3435                 if (status == BT_ACTIVATING) {
3436                         BT_DBG("Enabling in progress");
3437                         result = BLUETOOTH_ERROR_IN_PROGRESS;
3438                 } else if (status == BT_ACTIVATED) {
3439                         BT_DBG("Already enabled");
3440                         result = BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED;
3441                 } else {
3442                         _bt_adapter_set_status(BT_ACTIVATING);
3443
3444 #if TODO_40 /* Need to add this function */
3445                         _bt_adapter_start_enable_timer();
3446 #endif
3447                         result = BLUETOOTH_ERROR_NONE;
3448                 }
3449
3450                 break;
3451         }
3452         case BT_DISABLE_ADAPTER:
3453         {
3454                 bt_status_t status;
3455
3456                 status = _bt_adapter_get_status();
3457                 if (status == BT_DEACTIVATING) {
3458                                 BT_DBG("Disabling in progress");
3459                                 result = BLUETOOTH_ERROR_IN_PROGRESS;
3460                 } else if (status == BT_DEACTIVATED) {
3461                                 BT_DBG("Already disabled");
3462                                 result = BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
3463                 } else {
3464                         _bt_adapter_set_status(BT_DEACTIVATING);
3465                         result = BLUETOOTH_ERROR_NONE;
3466                 }
3467
3468                 break;
3469         }
3470         case BT_ENABLE_ADAPTER_LE:
3471         {
3472                 bt_le_status_t le_status;
3473
3474                 le_status = _bt_adapter_get_le_status();
3475                 if (le_status == BT_LE_ACTIVATING) {
3476                         BT_DBG("Enabling in progress");
3477                         result = BLUETOOTH_ERROR_IN_PROGRESS;
3478                 } else if (le_status == BT_LE_ACTIVATED) {
3479                         BT_DBG("Already enabled");
3480                         result = BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED;
3481                 } else {
3482                         _bt_adapter_set_le_status(BT_LE_ACTIVATING);
3483
3484 #if TODO_40 /* Need to add this function */
3485                         _bt_adapter_start_le_enable_timer();
3486 #endif
3487                         result = BLUETOOTH_ERROR_NONE;
3488                 }
3489
3490                 break;
3491         }
3492         case BT_DISABLE_ADAPTER_LE:
3493         {
3494                 bt_le_status_t le_status;
3495
3496                 le_status = _bt_adapter_get_le_status();
3497                 if (le_status == BT_LE_DEACTIVATING) {
3498                                 BT_DBG("Disabling in progress");
3499                                 result = BLUETOOTH_ERROR_IN_PROGRESS;
3500                 } else if (le_status == BT_LE_DEACTIVATED) {
3501                                 BT_DBG("Already disabled");
3502                                 result = BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
3503                 } else {
3504                         _bt_adapter_set_le_status(BT_LE_DEACTIVATING);
3505                         result = BLUETOOTH_ERROR_NONE;
3506                 }
3507
3508                 break;
3509         }
3510         default:
3511                 BT_ERR("Unknown function!");
3512                 result = BLUETOOTH_ERROR_INTERNAL;
3513                 break;
3514         }
3515
3516         return result;
3517 }
3518
3519 gboolean __bt_service_check_privilege(int function_name,
3520                                         int service_type,
3521                                         const char *unique_name)
3522 {
3523         int ret_val;
3524         gboolean result = TRUE;
3525         char *client_creds = NULL;
3526         char *user_creds = NULL;
3527         char *client_session = "";
3528         enum cynara_client_creds client_creds_method = CLIENT_METHOD_SMACK;
3529         enum cynara_user_creds user_creds_method = USER_METHOD_UID;
3530         char err_msg[256] = {0, };
3531
3532         retv_if(unique_name == NULL, FALSE);
3533         retv_if(bt_service_conn == NULL, FALSE);
3534
3535         ret_val = cynara_creds_get_default_client_method(&client_creds_method);
3536         if (ret_val != CYNARA_API_SUCCESS) {
3537                 cynara_strerror(ret_val, err_msg, sizeof(err_msg));
3538                 BT_ERR("Fail to get default client method: %s", err_msg);
3539                 return FALSE;
3540         }
3541
3542         ret_val = cynara_creds_get_default_user_method(&user_creds_method);
3543         if (ret_val != CYNARA_API_SUCCESS) {
3544                 cynara_strerror(ret_val, err_msg, sizeof(err_msg));
3545                 BT_ERR("Fail to get default user method: %s", err_msg);
3546                 return FALSE;
3547         }
3548
3549         ret_val = cynara_creds_gdbus_get_client(bt_service_conn, unique_name, client_creds_method, &client_creds);
3550         if (ret_val != CYNARA_API_SUCCESS) {
3551                 cynara_strerror(ret_val, err_msg, sizeof(err_msg));
3552                 BT_ERR("Fail to get client credential: %s", err_msg);
3553                 return FALSE;
3554         }
3555
3556         ret_val = cynara_creds_gdbus_get_user(bt_service_conn, unique_name, user_creds_method, &user_creds);
3557         if (ret_val != CYNARA_API_SUCCESS) {
3558                 cynara_strerror(ret_val, err_msg, sizeof(err_msg));
3559                 BT_ERR("Fail to get user credential: %s", err_msg);
3560                 if (client_creds)
3561                         free(client_creds);
3562                 return FALSE;
3563         }
3564
3565         BT_DBG("%s, %s, %s", unique_name, client_creds, user_creds);
3566
3567         switch (function_name) {
3568         case BT_SET_LOCAL_NAME:
3569         case BT_START_DISCOVERY:
3570         case BT_START_CUSTOM_DISCOVERY:
3571         case BT_CANCEL_DISCOVERY:
3572         case BT_OOB_ADD_REMOTE_DATA:
3573         case BT_OOB_REMOVE_REMOTE_DATA:
3574         case BT_SET_ADVERTISING:
3575         case BT_SET_CUSTOM_ADVERTISING:
3576         case BT_SET_ADVERTISING_PARAMETERS:
3577         case BT_START_LE_DISCOVERY:
3578         case BT_STOP_LE_DISCOVERY:
3579         case BT_SET_SCAN_PARAMETERS:
3580
3581         case BT_BOND_DEVICE:
3582         case BT_CANCEL_BONDING:
3583         case BT_UNBOND_DEVICE:
3584         case BT_SET_ALIAS:
3585         case BT_SET_AUTHORIZATION:
3586         case BT_UNSET_AUTHORIZATION:
3587         case BT_SEARCH_SERVICE:
3588
3589         case BT_RFCOMM_CLIENT_CONNECT:
3590         case BT_RFCOMM_CLIENT_CANCEL_CONNECT:
3591         case BT_RFCOMM_SOCKET_DISCONNECT:
3592         case BT_RFCOMM_SOCKET_WRITE:
3593         case BT_RFCOMM_CREATE_SOCKET:
3594         case BT_RFCOMM_REMOVE_SOCKET:
3595
3596         case BT_OPP_PUSH_FILES:
3597         case BT_OPP_CANCEL_PUSH:
3598         /* TODO: MAP? MAP functions, see above */
3599
3600         case BT_OBEX_SERVER_ACCEPT_CONNECTION:
3601         case BT_OBEX_SERVER_REJECT_CONNECTION:
3602         case BT_OBEX_SERVER_ACCEPT_FILE:
3603         case BT_OBEX_SERVER_REJECT_FILE:
3604         case BT_OBEX_SERVER_SET_PATH:
3605         case BT_OBEX_SERVER_SET_ROOT:
3606         case BT_OBEX_SERVER_CANCEL_TRANSFER:
3607         case BT_OBEX_SERVER_CANCEL_ALL_TRANSFERS:
3608
3609         case BT_AUDIO_SELECT_ROLE:
3610         case BT_AUDIO_CONNECT:
3611         case BT_AUDIO_DISCONNECT:
3612         case BT_AG_CONNECT:
3613         case BT_AG_DISCONNECT:
3614         case BT_AV_CONNECT:
3615         case BT_AV_DISCONNECT:
3616         case BT_AV_SOURCE_CONNECT:
3617         case BT_AV_SOURCE_DISCONNECT:
3618         case BT_AVRCP_TARGET_CONNECT:
3619         case BT_AVRCP_TARGET_DISCONNECT:
3620         case BT_AVRCP_CONTROL_CONNECT:
3621         case BT_AVRCP_CONTROL_DISCONNECT:
3622         case BT_AVRCP_HANDLE_CONTROL:
3623         case BT_AVRCP_SET_TRACK_INFO:
3624         case BT_AVRCP_SET_PROPERTY:
3625         case BT_AVRCP_SET_PROPERTIES:
3626         case BT_AVRCP_CONTROL_SET_PROPERTY:
3627
3628         case BT_HF_CONNECT:
3629         case BT_HF_DISCONNECT:
3630
3631         case BT_HID_CONNECT:
3632         case BT_HID_DISCONNECT:
3633
3634         case BT_HID_DEVICE_ACTIVATE:
3635         case BT_HID_DEVICE_DEACTIVATE:
3636         case BT_HID_DEVICE_CONNECT:
3637         case BT_HID_DEVICE_DISCONNECT:
3638         case BT_HID_DEVICE_SEND_MOUSE_EVENT:
3639         case BT_HID_DEVICE_SEND_KEY_EVENT:
3640         case BT_HID_DEVICE_SEND_REPLY_TO_REPORT:
3641         case BT_HID_DEVICE_SEND_CUSTOM_EVENT:
3642
3643         case BT_CONNECT_LE:
3644         case BT_DISCONNECT_LE:
3645
3646         case BT_SET_ADVERTISING_DATA:
3647         case BT_SET_SCAN_RESPONSE_DATA:
3648
3649         case BT_HDP_CONNECT:
3650         case BT_HDP_DISCONNECT:
3651         case BT_HDP_SEND_DATA:
3652         case BT_HDP_REGISTER_SINK_APP:
3653         case BT_HDP_UNREGISTER_SINK_APP:
3654         case BT_HDP_GET_FD:
3655
3656         case BT_DPM_SET_ALLOW_BT_MODE:
3657         case BT_DPM_GET_ALLOW_BT_MODE:
3658         case BT_DPM_SET_DEVICE_RESTRITION:
3659         case BT_DPM_GET_DEVICE_RESTRITION:
3660         case BT_DPM_SET_UUID_RESTRITION:
3661         case BT_DPM_GET_UUID_RESTRITION:
3662         case BT_DPM_ADD_DEVICES_BLACKLIST:
3663         case BT_DPM_ADD_DEVICES_WHITELIST:
3664         case BT_DPM_ADD_UUIDS_BLACKLIST:
3665         case BT_DPM_ADD_UUIDS_WHITELIST:
3666         case BT_DPM_CLEAR_DEVICES_BLACKLIST:
3667         case BT_DPM_CLEAR_DEVICES_WHITELIST:
3668         case BT_DPM_CLEAR_UUIDS_BLACKLIST:
3669         case BT_DPM_CLEAR_UUIDS_WHITELIST:
3670         case BT_DPM_REMOVE_DEVICE_BLACKLIST:
3671         case BT_DPM_REMOVE_DEVICE_WHITELIST:
3672         case BT_DPM_REMOVE_UUID_BLACKLIST:
3673         case BT_DPM_REMOVE_UUID_WHITELIST:
3674         case BT_DPM_GET_DEVICES_BLACKLIST:
3675         case BT_DPM_GET_DEVICES_WHITELIST:
3676         case BT_DPM_GET_UUIDS_BLACKLIST:
3677         case BT_DPM_GET_UUIDS_WHITELIST:
3678         case BT_DPM_SET_ALLOW_OUTGOING_CALL:
3679         case BT_DPM_GET_ALLOW_OUTGOING_CALL:
3680         case BT_DPM_SET_PAIRING_STATE:
3681         case BT_DPM_GET_PAIRING_STATE:
3682         case BT_DPM_SET_PROFILE_STATE:
3683         case BT_DPM_GET_PROFILE_STATE:
3684         case BT_DPM_SET_DESKROP_CONNECTIVITY_STATE:
3685         case BT_DPM_GET_DESKROP_CONNECTIVITY_STATE:
3686         case BT_DPM_SET_DISCOVERABLE_STATE:
3687         case BT_DPM_GET_DISCOVERABLE_STATE:
3688         case BT_DPM_SET_LIMITED_DISCOVERABLE_STATE:
3689         case BT_DPM_GET_LIMITED_DISCOVERABLE_STATE:
3690         case BT_DPM_SET_DATA_TRANSFER_STATE:
3691         case BT_DPM_GET_DATA_TRANSFER_STATE:
3692
3693         case BT_NETWORK_ACTIVATE:
3694         case BT_NETWORK_DEACTIVATE:
3695         case BT_NETWORK_CONNECT:
3696         case BT_NETWORK_DISCONNECT:
3697         case BT_NETWORK_SERVER_DISCONNECT:
3698
3699         case BT_GATT_GET_PRIMARY_SERVICES:
3700 #ifdef TIZEN_GATT_CLIENT
3701         case BT_GATT_GET_SERVICE_PROPERTIES:             /* GATT Client */
3702         case BT_GATT_GET_CHARACTERISTIC_PROPERTIES:      /* GATT Client */
3703         case BT_GATT_WATCH_SERVICE_CHANGED_INDICATION:   /* GATT Client */
3704 #endif
3705         case BT_GATT_DISCOVER_CHARACTERISTICS:
3706         case BT_GATT_SET_PROPERTY_REQUEST:
3707         case BT_GATT_READ_CHARACTERISTIC:
3708 #ifdef TIZEN_GATT_CLIENT
3709         case BT_GATT_READ_DESCRIPTOR_VALUE:              /* GATT Client */
3710         case BT_GATT_WRITE_CHARACTERISTIC_VALUE_BY_TYPE: /* GATT Client */
3711         case BT_GATT_ACQUIRE_WRITE:
3712         case BT_GATT_WRITE_DESCRIPTOR_VALUE:             /* GATT Client */
3713         case BT_GATT_WATCH_CHARACTERISTIC:               /* GATT Client */
3714         case BT_GATT_CLIENT_REGISTER:                    /* GATT Client */
3715         case BT_GATT_CLIENT_UNREGISTER:                   /* GATT Client */
3716 #endif
3717         case BT_GATT_DISCOVER_CHARACTERISTICS_DESCRIPTOR:
3718         case BT_GATT_REGISTER_APPLICATION:
3719         case BT_GATT_REGISTER_SERVICE:
3720         case BT_GATT_SEND_RESPONSE:
3721 #ifndef GATT_DIRECT
3722         case BT_GATT_SERVER_REGISTER:
3723         case BT_GATT_SERVER_ADD_SERVICE:
3724         case BT_GATT_SERVER_ADD_CHARACTERISTIC:
3725         case BT_GATT_SERVER_ADD_DESCRIPTOR:
3726         case BT_GATT_SERVER_START_SERVICE:
3727         case BT_GATT_SERVER_STOP_SERVICE:
3728         case BT_GATT_SERVER_DELETE_SERVICE:
3729         case BT_GATT_SERVER_SEND_RESPONSE:
3730         case BT_GATT_SERVER_ACQURE_WRITE_RESPONSE:
3731         case BT_GATT_SERVER_ACQUIRE_NOTIFY_RESPONSE:
3732         case BT_GATT_SERVER_SEND_INDICATION:
3733         case BT_GATT_SERVER_UPDATE_VALUE:
3734         case BT_GATT_SERVER_DEREGISTER:
3735 #endif
3736         case BT_REQ_ATT_MTU:
3737         case BT_PBAP_CONNECT:
3738         case BT_PBAP_DISCONNECT:
3739         case BT_PBAP_GET_PHONEBOOK_SIZE:
3740         case BT_PBAP_GET_PHONEBOOK:
3741         case BT_PBAP_GET_LIST:
3742         case BT_PBAP_PULL_VCARD:
3743         case BT_PBAP_PHONEBOOK_SEARCH:
3744
3745         case BT_RFCOMM_LISTEN_AND_ACCEPT:
3746
3747         ret_val = cynara_check(p_cynara, client_creds, client_session, user_creds,
3748                                                 BT_PRIVILEGE_PUBLIC);
3749
3750         if (ret_val != CYNARA_API_ACCESS_ALLOWED) {
3751                 BT_ERR("Fail to access: %s", BT_PRIVILEGE_PUBLIC);
3752                 result = FALSE;
3753         }
3754
3755         /* Need to check mediastorage privilege */
3756         if (function_name == BT_PBAP_GET_PHONEBOOK ||
3757                 function_name == BT_PBAP_PULL_VCARD) {
3758                 ret_val = cynara_check(p_cynara, client_creds, client_session, user_creds,
3759                                                         MEDIASTORAGE_PRIVILEGE);
3760
3761                 if (ret_val != CYNARA_API_ACCESS_ALLOWED) {
3762                 BT_ERR("Fail to access: %s", MEDIASTORAGE_PRIVILEGE);
3763                 result = FALSE;
3764                 }
3765         }
3766         break;
3767
3768         case BT_ENABLE_ADAPTER:
3769         case BT_DISABLE_ADAPTER:
3770         case BT_RESET_ADAPTER:
3771         case BT_RECOVER_ADAPTER:
3772         case BT_ENABLE_ADAPTER_LE:
3773         case BT_DISABLE_ADAPTER_LE:
3774         case BT_SET_CONNECTABLE:
3775         case BT_SET_DISCOVERABLE_MODE:
3776         case BT_ADD_WHITE_LIST:
3777         case BT_REMOVE_WHITE_LIST:
3778         case BT_CLEAR_WHITE_LIST:
3779         case BT_SET_MANUFACTURER_DATA:
3780
3781         case BT_CANCEL_SEARCH_SERVICE:
3782         case BT_ENABLE_RSSI:
3783
3784         case BT_RFCOMM_ACCEPT_CONNECTION:
3785         case BT_RFCOMM_REJECT_CONNECTION:
3786         case BT_RFCOMM_LISTEN:
3787
3788         case BT_HID_ENABLE_BARCODE_FEATURE:
3789
3790         case BT_AVRCP_CONTROL_GET_PROPERTY:
3791         case BT_AVRCP_GET_TRACK_INFO:
3792         case BT_AVRCP_TRANSPORT_SET_PROPERTY:
3793
3794
3795         case BT_SET_CONTENT_PROTECT:
3796         case BT_BOND_DEVICE_BY_TYPE:
3797         case BT_SET_LE_PRIVACY:
3798         case BT_SET_LE_STATIC_RANDOM_ADDRESS:
3799         case BT_LE_CONN_UPDATE:
3800         case BT_UPDATE_LE_CONNECTION_MODE:
3801         case BT_GET_DEVICE_IDA:
3802         case BT_LE_READ_MAXIMUM_DATA_LENGTH:
3803         case BT_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH:
3804         case BT_LE_READ_HOST_SUGGESTED_DATA_LENGTH:
3805         case BT_LE_SET_DATA_LENGTH:
3806
3807         case BT_LE_IPSP_INIT:
3808         case BT_LE_IPSP_DEINIT:
3809         case BT_LE_IPSP_CONNECT:
3810         case BT_LE_IPSP_DISCONNECT:
3811         case BT_PXP_MONITOR_SET_PROPERTY:
3812         case BT_PXP_MONITOR_GET_PROPERTY:
3813         case BT_PXP_MONITOR_GET_SUPPORTED_SERIVCES:
3814         case BT_PXP_REPORTER_REGISTER:
3815         case BT_PXP_REPORTER_UNREGISTER:
3816         case BT_PXP_REPORTER_GET_PROPERTY:
3817
3818         /* TDS */
3819         case BT_TDS_PROVIDER_REGISTER:
3820         case BT_TDS_PROVIDER_UNREGISTER:
3821         case BT_TDS_PROVIDER_SET_MANUF_DATA:
3822         case BT_TDS_PROVIDER_CREATE:
3823         case BT_TDS_PROVIDER_DESTROY:
3824         case BT_TDS_PROVIDER_SET_TRANSPORT_DATA:
3825         case BT_TDS_SEND_ACTIVATION_RESPONSE:
3826         case BT_TDS_READ_TRANSPORT_DATA:
3827         case BT_TDS_ENABLE_CONTROL_POINT:
3828         case BT_TDS_ACTIVATE_CONTROL_POINT:
3829
3830         /* OTP Server */
3831         case BT_OTP_SERVER_INIT:
3832         case BT_OTP_SERVER_DEINIT:
3833         case BT_OTP_READ_VALUE:
3834         case BT_OTP_ENABLE_NOTIFICATION:
3835         case BT_OTP_WRITE_VALUE:
3836         case BT_LE_OTC_CONNECT:
3837         case BT_LE_OTC_DISCONNECT:
3838
3839         case BT_MAP_CREATE_SESSION:
3840         case BT_MAP_DESTROY_SESSION:
3841         case BT_MAP_SET_FOLDER:
3842         case BT_MAP_LIST_FOLDERS:
3843         case BT_MAP_LIST_FILTER_FIELDS:
3844         case BT_MAP_LIST_MESSAGES:
3845         case BT_MAP_UPDATE_INBOX:
3846         case BT_MAP_PUSH_MESSAGE:
3847         case BT_MAP_GET_MESSAGE:
3848
3849         ret_val = cynara_check(p_cynara, client_creds, client_session, user_creds,
3850                                 BT_PRIVILEGE_PLATFORM);
3851
3852         if (ret_val != CYNARA_API_ACCESS_ALLOWED) {
3853                 BT_ERR("Fail to access: %s", BT_PRIVILEGE_PLATFORM);
3854                 result = FALSE;
3855         }
3856         break;
3857
3858         case BT_CHECK_ADAPTER:
3859         case BT_GET_RSSI:
3860
3861         case BT_GET_LOCAL_NAME:
3862         case BT_GET_LOCAL_ADDRESS:
3863         case BT_GET_LOCAL_VERSION:
3864         case BT_IS_SERVICE_USED:
3865         case BT_GET_DISCOVERABLE_MODE:
3866         case BT_GET_DISCOVERABLE_TIME:
3867         case BT_IS_DISCOVERYING:
3868         case BT_IS_LE_DISCOVERYING:
3869         case BT_IS_CONNECTABLE:
3870         case BT_GET_BONDED_DEVICES:
3871         case BT_GET_PROFILE_CONNECTED_DEVICES:
3872         case BT_GET_BONDED_DEVICE:
3873         case BT_PASSKEY_REPLY:
3874         case BT_PASSKEY_CONFIRMATION_REPLY:
3875         case BT_GET_IS_ALIAS_SET:
3876         case BT_IS_DEVICE_CONNECTED:
3877         case BT_GET_CONNECTED_LINK_TYPE:
3878         case BT_SET_PROFILE_TRUSTED:
3879         case BT_GET_PROFILE_TRUSTED:
3880         case BT_GET_SPEAKER_GAIN:
3881         case BT_SET_SPEAKER_GAIN:
3882         case BT_OOB_READ_LOCAL_DATA:
3883         case BT_RFCOMM_CLIENT_IS_CONNECTED:
3884         case BT_RFCOMM_IS_UUID_AVAILABLE:
3885         case BT_GET_ADVERTISING_DATA:
3886         case BT_GET_SCAN_RESPONSE_DATA:
3887         case BT_IS_ADVERTISING:
3888         case BT_IS_LE_2M_PHY_SUPPORTED:
3889         case BT_IS_LE_CODED_PHY_SUPPORTED:
3890         case BT_REGISTER_SCAN_FILTER:
3891         case BT_UNREGISTER_SCAN_FILTER:
3892         case BT_UNREGISTER_ALL_SCAN_FILTERS:
3893         case BT_IS_SCAN_FILTER_SUPPORTED:
3894         case BT_GET_ATT_MTU:
3895
3896         case BT_OBEX_SERVER_ALLOCATE:
3897         case BT_OBEX_SERVER_DEALLOCATE:
3898         case BT_OBEX_SERVER_IS_ACTIVATED:
3899         case BT_OPP_GET_TRANSFER_PROGRESS:
3900                 /* Non-privilege control */
3901                 break;
3902         default:
3903                 BT_ERR("Unknown function!");
3904                 result = FALSE;
3905                 break;
3906         }
3907
3908         if (client_creds)
3909                 free(client_creds);
3910
3911         if (user_creds)
3912                 free(user_creds);
3913
3914         return result;
3915 }
3916
3917 GDBusNodeInfo *__bt_service_create_method_node_info
3918                                         (const gchar *introspection_data)
3919 {
3920         GError *err = NULL;
3921         GDBusNodeInfo *node_info = NULL;
3922
3923         if (introspection_data == NULL) {
3924                 BT_ERR("Introspection XML not present");
3925                 return NULL;
3926         }
3927
3928         node_info = g_dbus_node_info_new_for_xml(introspection_data, &err);
3929
3930         if (err) {
3931                 BT_ERR("Unable to create node: %s", err->message);
3932                 g_clear_error(&err);
3933         }
3934         return node_info;
3935 }
3936
3937 int __bt_service_register_object(GDBusConnection *conn,
3938                 GDBusNodeInfo *node_info, gboolean reg)
3939 {
3940         static guint service_id = 0;
3941         GError *error = NULL;
3942
3943         if (reg) {
3944                 if (node_info == NULL)
3945                         return -1;
3946
3947                 service_id = g_dbus_connection_register_object(conn,
3948                                 BT_SERVICE_PATH,
3949                                 node_info->interfaces[0],
3950                                 &method_table,
3951                                 NULL, NULL, &error);
3952                 if (service_id == 0)
3953                         return -1;
3954         } else {
3955                 if (service_id > 0) {
3956                         g_dbus_connection_unregister_object(conn,
3957                                         service_id);
3958                         service_id = 0;
3959                 }
3960         }
3961
3962         return 0;
3963 }
3964
3965 static void __name_owner_changed(GDBusConnection *connection,
3966                 const gchar *sender_name,
3967                 const gchar *object_path,
3968                 const gchar *interface_name,
3969                 const gchar *signal_name,
3970                 GVariant *parameters,
3971                 gpointer user_data)
3972 {
3973         const char *name = NULL;
3974         const char *old_owner = NULL;
3975         const char *new_owner = NULL;
3976
3977         g_variant_get(parameters, "(&s&s&s)", &name, &old_owner, &new_owner);
3978         if (*new_owner != '\0')
3979                 return;
3980
3981         _bt_check_hdp_app_termination(name);
3982
3983         /* Advertising App Termination */
3984         _bt_check_adv_app_termination(name);
3985
3986         /* Check if le_scanning app is terminated */
3987         _bt_check_le_scanner_app_termination(name);
3988 }
3989
3990 static void __bt_service_bus_acquired_handler(GDBusConnection *connection,
3991                 const gchar *name, gpointer user_data)
3992 {
3993         GDBusNodeInfo *node_info = NULL;
3994
3995         BT_INFO("bus acquired");
3996
3997         ret_if(connection == NULL);
3998
3999         node_info = __bt_service_create_method_node_info(
4000                         bt_service_introspection_xml);
4001         ret_if(node_info == NULL);
4002
4003         __bt_service_register_object(connection, node_info, TRUE);
4004         g_dbus_node_info_unref(node_info);
4005
4006         bt_service_conn = connection;
4007 }
4008
4009 static void __bt_service_name_acquired_handler(GDBusConnection *connection,
4010                 const gchar *name, gpointer user_data)
4011 {
4012         BT_INFO("name acquired");
4013         name_acquired = TRUE;
4014 }
4015
4016 static void __bt_service_name_lost_handler(GDBusConnection *connection,
4017                 const gchar *name, gpointer user_data)
4018 {
4019         BT_INFO("name lost");
4020         name_acquired = FALSE;
4021 }
4022
4023 gboolean _is_name_acquired(void)
4024 {
4025         return name_acquired;
4026 }
4027
4028 int _bt_service_register(void)
4029 {
4030         GDBusConnection *conn;
4031         GError *err = NULL;
4032
4033         conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
4034         retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
4035         bt_service_conn = conn;
4036
4037         owner_id = g_bus_own_name(G_BUS_TYPE_SYSTEM,
4038                                 BT_SERVICE_NAME,
4039                                 G_BUS_NAME_OWNER_FLAGS_NONE,
4040                                 __bt_service_bus_acquired_handler,
4041                                 __bt_service_name_acquired_handler,
4042                                 __bt_service_name_lost_handler,
4043                                 NULL, NULL);
4044         BT_DBG("owner_id is [%d]", owner_id);
4045         if (owner_id == 0)
4046                 goto fail;
4047
4048         /* Subscribe for name owner changed signal */
4049         owner_sig_id = g_dbus_connection_signal_subscribe(conn,
4050                         BT_FREEDESKTOP_SERVICE, BT_FREEDESKTOP_INTERFACE,
4051                         BT_NAME_OWNER_CHANGED, NULL, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
4052                         __name_owner_changed, NULL, NULL);
4053         BT_INFO("owner_sig_id: %d", owner_sig_id);
4054
4055         return BLUETOOTH_ERROR_NONE;
4056
4057 fail:
4058         if (bt_service_conn) {
4059                 g_object_unref(bt_service_conn);
4060                 bt_service_conn = NULL;
4061         }
4062
4063         return BLUETOOTH_ERROR_INTERNAL;
4064 }
4065
4066 void _bt_service_unregister(void)
4067 {
4068         if (bt_service_conn) {
4069                 if (owner_sig_id > 0) {
4070                         g_dbus_connection_signal_unsubscribe(
4071                                         bt_service_conn, owner_sig_id);
4072                         owner_sig_id = 0;
4073                 }
4074
4075                 __bt_service_register_object(bt_service_conn, NULL, FALSE);
4076                 if (bt_service_conn) {
4077                         g_object_unref(bt_service_conn);
4078                         bt_service_conn = NULL;
4079                 }
4080                 if (owner_id > 0) {
4081                         g_bus_unown_name(owner_id);
4082                         owner_id = 0;
4083                 }
4084         }
4085 }
4086
4087 int _bt_service_cynara_init(void)
4088 {
4089         int result;
4090         char err_msg[256] = {0, };
4091
4092         retv_if(p_cynara != NULL, BLUETOOTH_ERROR_ALREADY_INITIALIZED);
4093
4094         result = cynara_initialize(&p_cynara, conf);
4095
4096         if (result != CYNARA_API_SUCCESS) {
4097                 cynara_strerror(result, err_msg, sizeof(err_msg));
4098                 BT_ERR("Fail to initialize cynara: [%s]", err_msg);
4099                 return BLUETOOTH_ERROR_INTERNAL;
4100         }
4101
4102         return BLUETOOTH_ERROR_NONE;
4103 }
4104
4105 void _bt_service_cynara_deinit(void)
4106 {
4107         int result;
4108         char err_msg[256] = {0, };
4109
4110         ret_if(p_cynara == NULL);
4111
4112         result = cynara_finish(p_cynara);
4113
4114         if (result != CYNARA_API_SUCCESS) {
4115                 cynara_strerror(result, err_msg, sizeof(err_msg));
4116                 BT_ERR("Fail to finish cynara: [%s]", err_msg);
4117                 return;
4118         }
4119
4120         p_cynara = NULL;
4121         conf = NULL;
4122 }
4123
4124 void _bt_service_method_return(GDBusMethodInvocation *invocation,
4125                 GArray *out_param, int result)
4126 {
4127         GVariant *out_var;
4128         BT_DBG("+");
4129         out_var = g_variant_new_from_data((const GVariantType *)"ay",
4130                         out_param->data, out_param->len, TRUE, NULL, NULL);
4131
4132         g_dbus_method_invocation_return_value(invocation,
4133                         g_variant_new("(iv)", result, out_var));
4134         BT_DBG("-");
4135 }
4136
4137 void _bt_service_method_return_with_unix_fd_list(GDBusMethodInvocation *invocation,
4138                 GArray *out_param, int result, GUnixFDList *fd_list)
4139 {
4140         GVariant *out_var;
4141         BT_DBG("+");
4142         out_var = g_variant_new_from_data((const GVariantType *)"ay",
4143                         out_param->data, out_param->len, TRUE, NULL, NULL);
4144
4145         g_dbus_method_invocation_return_value_with_unix_fd_list(invocation,
4146                         g_variant_new("(iv)", result, out_var), fd_list);
4147         BT_DBG("-");
4148 }