src/tapi_call.c

   1 /*
   2  * libslp-tapi
   3  *
   4  * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Ja-young Gu <jygu@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  */
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24
  25 #include "TelCall.h"
  26 #include "tapi_common.h"
  27 #include "TapiUtility.h"
  28
  29 #include "common.h"
  30 #include "tapi_log.h"
  31 #include "ITapiCall.h"
  32 #include "tapi_private.h"
  33
  34 static void on_response_call_dial(GObject *source_object, GAsyncResult *res, gpointer user_data)
  35 {
  36         GError *error = 0;
  37         GDBusConnection *conn = 0;
  38         struct tapi_resp_data *evt_cb_data = user_data;
  39         int result = -1;
  40
  41         GVariant *dbus_result;
  42
  43         conn = G_DBUS_CONNECTION(source_object);
  44         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
  45         TAPI_RESP_CHECK_ERROR(error, evt_cb_data);
  46
  47         g_variant_get(dbus_result, "(i)", &result);
  48
  49         TAPI_INVOKE_RESP_CALLBACK(evt_cb_data, result, NULL);
  50
  51         g_free(evt_cb_data);
  52         g_variant_unref(dbus_result);
  53 }
  54
  55 static void on_response_call_answer(GObject *source_object, GAsyncResult *res, gpointer user_data)
  56 {
  57         GError *error = 0;
  58         GDBusConnection *conn = 0;
  59         struct tapi_resp_data *evt_cb_data = user_data;
  60         int result = -1;
  61         TelCallAnswerCnf_t data;
  62
  63         GVariant *dbus_result;
  64
  65         conn = G_DBUS_CONNECTION(source_object);
  66         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
  67         TAPI_RESP_CHECK_ERROR(error, evt_cb_data);
  68
  69         g_variant_get(dbus_result, "(ii)", &result, &data.id);
  70
  71         TAPI_INVOKE_RESP_CALLBACK(evt_cb_data, result, &data);
  72
  73         g_free(evt_cb_data);
  74         g_variant_unref(dbus_result);
  75 }
  76
  77 static void on_response_call_end(GObject *source_object, GAsyncResult *res, gpointer user_data)
  78 {
  79         GError *error = 0;
  80         GDBusConnection *conn = 0;
  81         struct tapi_resp_data *evt_cb_data = user_data;
  82         int result = -1;
  83         TelCallEndCnf_t data;
  84
  85         GVariant *dbus_result;
  86
  87         conn = G_DBUS_CONNECTION(source_object);
  88         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
  89         TAPI_RESP_CHECK_ERROR(error, evt_cb_data);
  90
  91         g_variant_get(dbus_result, "(iii)", &result, &data.id, &data.type);
  92
  93         TAPI_INVOKE_RESP_CALLBACK(evt_cb_data, result, &data);
  94
  95         g_free(evt_cb_data);
  96         g_variant_unref(dbus_result);
  97 }
  98
  99 static void on_response_call_hold(GObject *source_object, GAsyncResult *res, gpointer user_data)
 100 {
 101         GError *error = 0;
 102         GDBusConnection *conn = 0;
 103         struct tapi_resp_data *evt_cb_data = user_data;
 104         int result = -1;
 105         TelCallHoldCnf_t data;
 106
 107         GVariant *dbus_result;
 108
 109         conn = G_DBUS_CONNECTION(source_object);
 110         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 111         TAPI_RESP_CHECK_ERROR(error, evt_cb_data);
 112
 113         g_variant_get(dbus_result, "(ii)", &result, &data.id);
 114
 115         TAPI_INVOKE_RESP_CALLBACK(evt_cb_data, result, &data);
 116
 117         g_free(evt_cb_data);
 118         g_variant_unref(dbus_result);
 119 }
 120
 121 static void on_response_call_active(GObject *source_object, GAsyncResult *res, gpointer user_data)
 122 {
 123         GError *error = 0;
 124         GDBusConnection *conn = 0;
 125         struct tapi_resp_data *evt_cb_data = user_data;
 126         int result = -1;
 127         TelCallActiveCnf_t data;
 128
 129         GVariant *dbus_result;
 130
 131         conn = G_DBUS_CONNECTION(source_object);
 132         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 133         TAPI_RESP_CHECK_ERROR(error, evt_cb_data);
 134
 135         g_variant_get(dbus_result, "(ii)", &result, &data.id);
 136
 137         TAPI_INVOKE_RESP_CALLBACK(evt_cb_data, result, &data);
 138
 139         g_free(evt_cb_data);
 140         g_variant_unref(dbus_result);
 141 }
 142
 143 static void on_response_call_swap(GObject *source_object, GAsyncResult *res, gpointer user_data)
 144 {
 145         GError *error = 0;
 146         GDBusConnection *conn = 0;
 147         struct tapi_resp_data *evt_cb_data = user_data;
 148         int result = -1;
 149         TelCallSwapCnf_t data;
 150
 151         GVariant *dbus_result;
 152
 153         conn = G_DBUS_CONNECTION(source_object);
 154         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 155         TAPI_RESP_CHECK_ERROR(error, evt_cb_data);
 156
 157         g_variant_get(dbus_result, "(ii)", &result, &data.id);
 158
 159         TAPI_INVOKE_RESP_CALLBACK(evt_cb_data, result, &data);
 160
 161         g_free(evt_cb_data);
 162         g_variant_unref(dbus_result);
 163 }
 164
 165 static void on_response_call_join(GObject *source_object, GAsyncResult *res, gpointer user_data)
 166 {
 167         GError *error = 0;
 168         GDBusConnection *conn = 0;
 169         struct tapi_resp_data *evt_cb_data = user_data;
 170         int result = -1;
 171         TelCallJoinCnf_t data;
 172
 173         GVariant *dbus_result;
 174
 175         conn = G_DBUS_CONNECTION(source_object);
 176         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 177         TAPI_RESP_CHECK_ERROR(error, evt_cb_data);
 178
 179         g_variant_get(dbus_result, "(ii)", &result, &data.id);
 180
 181         TAPI_INVOKE_RESP_CALLBACK(evt_cb_data, result, &data);
 182
 183         g_free(evt_cb_data);
 184         g_variant_unref(dbus_result);
 185 }
 186
 187 static void on_response_call_split(GObject *source_object, GAsyncResult *res, gpointer user_data)
 188 {
 189         GError *error = 0;
 190         GDBusConnection *conn = 0;
 191         struct tapi_resp_data *evt_cb_data = user_data;
 192         int result = -1;
 193         TelCallSplitCnf_t data;
 194
 195         GVariant *dbus_result;
 196
 197         conn = G_DBUS_CONNECTION(source_object);
 198         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 199         TAPI_RESP_CHECK_ERROR(error, evt_cb_data);
 200
 201         g_variant_get(dbus_result, "(ii)", &result, &data.id);
 202
 203         TAPI_INVOKE_RESP_CALLBACK(evt_cb_data, result, &data);
 204
 205         g_free(evt_cb_data);
 206         g_variant_unref(dbus_result);
 207 }
 208
 209 static void on_response_call_transfer(GObject *source_object, GAsyncResult *res, gpointer user_data)
 210 {
 211         GError *error = 0;
 212         GDBusConnection *conn = 0;
 213         struct tapi_resp_data *evt_cb_data = user_data;
 214         int result = -1;
 215         TelCallTransferCnf_t data;
 216
 217         GVariant *dbus_result;
 218
 219         conn = G_DBUS_CONNECTION(source_object);
 220         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 221         TAPI_RESP_CHECK_ERROR(error, evt_cb_data);
 222
 223         g_variant_get(dbus_result, "(ii)", &result, &data.id);
 224
 225         TAPI_INVOKE_RESP_CALLBACK(evt_cb_data, result, &data);
 226
 227         g_free(evt_cb_data);
 228         g_variant_unref(dbus_result);
 229 }
 230
 231 static void on_response_call_dtmf(GObject *source_object, GAsyncResult *res, gpointer user_data)
 232 {
 233         GError *error = 0;
 234         GDBusConnection *conn = 0;
 235         struct tapi_resp_data *evt_cb_data = user_data;
 236         int result = -1;
 237
 238         GVariant *dbus_result;
 239
 240         conn = G_DBUS_CONNECTION(source_object);
 241         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 242         TAPI_RESP_CHECK_ERROR(error, evt_cb_data);
 243
 244         g_variant_get(dbus_result, "(i)", &result);
 245
 246         TAPI_INVOKE_RESP_CALLBACK(evt_cb_data, result, NULL);
 247
 248         g_free(evt_cb_data);
 249         g_variant_unref(dbus_result);
 250 }
 251
 252 static void on_response_call_deflect(GObject *source_object, GAsyncResult *res, gpointer user_data)
 253 {
 254         GError *error = 0;
 255         GDBusConnection *conn = 0;
 256         struct tapi_resp_data *evt_cb_data = user_data;
 257         int result = -1;
 258
 259         GVariant *dbus_result;
 260
 261         conn = G_DBUS_CONNECTION(source_object);
 262         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 263         TAPI_RESP_CHECK_ERROR(error, evt_cb_data);
 264
 265         g_variant_get(dbus_result, "(i)", &result);
 266
 267         TAPI_INVOKE_RESP_CALLBACK(evt_cb_data, result, NULL);
 268
 269         g_free(evt_cb_data);
 270         g_variant_unref(dbus_result);
 271 }
 272
 273 static void on_response_get_call_privacy_mode(GObject *source_object, GAsyncResult *res, gpointer user_data)
 274 {
 275         GError *error = 0;
 276         GDBusConnection *conn = 0;
 277         struct tapi_resp_data *evt_cb_data = user_data;
 278         int result = -1;
 279         TelCallGetPrivacyModeResp_t data;
 280
 281         GVariant *dbus_result;
 282
 283         conn = G_DBUS_CONNECTION(source_object);
 284         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 285         TAPI_RESP_CHECK_ERROR(error, evt_cb_data);
 286
 287         g_variant_get(dbus_result, "(ii)", &result, &data.mode);
 288
 289         TAPI_INVOKE_RESP_CALLBACK(evt_cb_data, result, &data);
 290
 291         g_free(evt_cb_data);
 292         g_variant_unref(dbus_result);
 293 }
 294
 295 static void on_response_set_call_privacy_mode(GObject *source_object, GAsyncResult *res, gpointer user_data)
 296 {
 297         GError *error = 0;
 298         GDBusConnection *conn = 0;
 299         struct tapi_resp_data *evt_cb_data = user_data;
 300         int result = -1;
 301
 302         GVariant *dbus_result;
 303
 304         conn = G_DBUS_CONNECTION(source_object);
 305         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 306         TAPI_RESP_CHECK_ERROR(error, evt_cb_data);
 307
 308         g_variant_get(dbus_result, "(i)", &result);
 309
 310         TAPI_INVOKE_RESP_CALLBACK(evt_cb_data, result, NULL);
 311
 312         g_free(evt_cb_data);
 313         g_variant_unref(dbus_result);
 314 }
 315
 316 static void on_response_get_call_volume_info(GObject *source_object, GAsyncResult *res, gpointer user_data)
 317 {
 318         GError *error = 0;
 319         GDBusConnection *conn = 0;
 320         struct tapi_resp_data *evt_cb_data = user_data;
 321         int result = -1, i = 0;
 322         TelCallGetVolumeInfoResp_t resp;
 323
 324         GVariant *dbus_result = 0, *value = 0;
 325         GVariantIter *iter = 0;
 326         GVariantIter *iter_row = 0;
 327         const gchar *key = 0;
 328
 329         memset(&resp, '\0', sizeof(TelCallGetVolumeInfoResp_t));
 330
 331         conn = G_DBUS_CONNECTION(source_object);
 332         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 333         TAPI_RESP_CHECK_ERROR(error, evt_cb_data);
 334
 335         g_variant_get(dbus_result, "(aa{sv}i)", &iter, &result);
 336
 337         resp.record_num = g_variant_iter_n_children(iter);
 338
 339         while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
 340                 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
 341                         if (!g_strcmp0(key, "type")) {
 342                                 int type = g_variant_get_int32(value);
 343
 344                                 resp.record[i].device = (type & 0xf0);
 345                                 resp.record[i].type = (type & 0x0f);
 346                         } else if (!g_strcmp0(key, "level")) {
 347                                 resp.record[i].volume = g_variant_get_int32(value);
 348                         }
 349                 }
 350                 g_variant_iter_free(iter_row);
 351                 i++;
 352         }
 353         g_variant_iter_free(iter);
 354
 355         TAPI_INVOKE_RESP_CALLBACK(evt_cb_data, result, &resp);
 356
 357         g_free(evt_cb_data);
 358         g_variant_unref(dbus_result);
 359 }
 360
 361 static void on_response_set_call_volume_info(GObject *source_object, GAsyncResult *res, gpointer user_data)
 362 {
 363         GError *error = 0;
 364         GDBusConnection *conn = 0;
 365         struct tapi_resp_data *evt_cb_data = user_data;
 366         int result = -1;
 367
 368         GVariant *dbus_result;
 369
 370         conn = G_DBUS_CONNECTION(source_object);
 371         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 372         TAPI_RESP_CHECK_ERROR(error, evt_cb_data);
 373
 374         g_variant_get(dbus_result, "(i)", &result);
 375
 376         TAPI_INVOKE_RESP_CALLBACK(evt_cb_data, result, NULL);
 377
 378         g_free(evt_cb_data);
 379         g_variant_unref(dbus_result);
 380 }
 381
 382 static void on_response_set_call_sound_path(GObject *source_object, GAsyncResult *res, gpointer user_data)
 383 {
 384         GError *error = 0;
 385         GDBusConnection *conn = 0;
 386         struct tapi_resp_data *evt_cb_data = user_data;
 387         int result = -1;
 388
 389         GVariant *dbus_result;
 390
 391         conn = G_DBUS_CONNECTION(source_object);
 392         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 393         TAPI_RESP_CHECK_ERROR(error, evt_cb_data);
 394
 395         g_variant_get(dbus_result, "(i)", &result);
 396
 397         TAPI_INVOKE_RESP_CALLBACK(evt_cb_data, result, NULL);
 398
 399         g_free(evt_cb_data);
 400         g_variant_unref(dbus_result);
 401 }
 402
 403 static void on_response_set_call_mute_status(GObject *source_object, GAsyncResult *res, gpointer user_data)
 404 {
 405         GError *error = 0;
 406         GDBusConnection *conn = 0;
 407         struct tapi_resp_data *evt_cb_data = user_data;
 408         int result = -1;
 409
 410         GVariant *dbus_result;
 411
 412         conn = G_DBUS_CONNECTION(source_object);
 413         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 414         TAPI_RESP_CHECK_ERROR(error, evt_cb_data);
 415
 416         g_variant_get(dbus_result, "(i)", &result);
 417
 418         TAPI_INVOKE_RESP_CALLBACK(evt_cb_data, result, NULL);
 419
 420         g_free(evt_cb_data);
 421         g_variant_unref(dbus_result);
 422 }
 423
 424 static void on_response_get_call_mute_status(GObject *source_object, GAsyncResult *res, gpointer user_data)
 425 {
 426         GError *error = 0;
 427         GDBusConnection *conn = 0;
 428         struct tapi_resp_data *evt_cb_data = user_data;
 429         int result = -1;
 430         TelCallGetMuteStatusResp_t resp;
 431
 432         GVariant *dbus_result;
 433
 434         conn = G_DBUS_CONNECTION(source_object);
 435         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 436         TAPI_RESP_CHECK_ERROR(error, evt_cb_data);
 437
 438         g_variant_get(dbus_result, "(iii)", &result, &resp.path, &resp.status);
 439
 440         TAPI_INVOKE_RESP_CALLBACK(evt_cb_data, result, &resp);
 441
 442         g_free(evt_cb_data);
 443         g_variant_unref(dbus_result);
 444 }
 445
 446 static void on_response_set_preferred_voice_subscription(GObject *source_object, GAsyncResult *res, gpointer user_data)
 447 {
 448         GError *error = 0;
 449         GDBusConnection *conn = 0;
 450         struct tapi_resp_data *evt_cb_data = user_data;
 451         int result = -1;
 452
 453         GVariant *dbus_result;
 454
 455         conn = G_DBUS_CONNECTION(source_object);
 456         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 457         TAPI_RESP_CHECK_ERROR(error, evt_cb_data);
 458
 459         g_variant_get(dbus_result, "(i)", &result);
 460
 461         TAPI_INVOKE_RESP_CALLBACK(evt_cb_data, result, NULL);
 462
 463         g_free(evt_cb_data);
 464         g_variant_unref(dbus_result);
 465 }
 466
 467 EXPORT_API int tel_dial_call(TapiHandle *handle, const TelCallDial_t *pParams, tapi_response_cb callback, void *user_data)
 468 {
 469         struct tapi_resp_data *evt_cb_data = 0;
 470         GVariant *param = 0;
 471
 472         TAPI_RET_ERR_NUM_IF_NOT_SUPPORTED(TELEPHONY_FEATURE);
 473         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 474         TAPI_RET_ERR_NUM_IF_FAIL(pParams, TAPI_API_INVALID_PTR);
 475
 476         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 477
 478         param = g_variant_new("(iis)", pParams->CallType, pParams->Ecc, pParams->szNumber);
 479
 480         msg("[%s] Request Dial. type:[%d]", handle->cp_name, pParams->CallType);
 481
 482         g_dbus_connection_call(handle->dbus_connection,
 483                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 484                         "Dial", param, 0,
 485                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 486                         on_response_call_dial, evt_cb_data);
 487
 488         return TAPI_API_SUCCESS;
 489 }
 490
 491
 492 EXPORT_API int tel_answer_call(TapiHandle *handle, unsigned int CallHandle, TelCallAnswerType_t AnsType, tapi_response_cb callback, void *user_data)
 493 {
 494         struct tapi_resp_data *evt_cb_data = 0;
 495         GVariant *param = 0;
 496
 497         TAPI_RET_ERR_NUM_IF_NOT_SUPPORTED(TELEPHONY_FEATURE);
 498         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 499
 500         if (AnsType > TAPI_CALL_ANSWER_HOLD_AND_ACCEPT)
 501                 return TAPI_API_INVALID_INPUT;
 502
 503         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 504
 505         param = g_variant_new("(iii)", CallHandle, AnsType, -1); /* -1 for AnsCallType */
 506
 507         msg("[%s] Request Answer. call_handle:[%d], type:[%d]", handle->cp_name, CallHandle, AnsType);
 508
 509         g_dbus_connection_call(handle->dbus_connection,
 510                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 511                         "Answer", param, 0,
 512                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 513                         on_response_call_answer, evt_cb_data);
 514
 515         return TAPI_API_SUCCESS;
 516 }
 517
 518 EXPORT_API int tel_end_call(TapiHandle *handle, unsigned int CallHandle, TelCallEndType_t EndType, tapi_response_cb callback, void *user_data)
 519 {
 520         struct tapi_resp_data *evt_cb_data = 0;
 521         GVariant *param = 0;
 522
 523         TAPI_RET_ERR_NUM_IF_NOT_SUPPORTED(TELEPHONY_FEATURE);
 524         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 525
 526         if (EndType > TAPI_CALL_END_HOLD_ALL)
 527                 return TAPI_API_INVALID_INPUT;
 528
 529         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 530
 531         param = g_variant_new("(ii)", CallHandle, EndType);
 532
 533         msg("[%s] Request End. call_handle:[%d], type:[%d]", handle->cp_name, CallHandle, EndType);
 534
 535         g_dbus_connection_call(handle->dbus_connection,
 536                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 537                         "End", param, 0,
 538                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 539                         on_response_call_end, evt_cb_data);
 540
 541         return TAPI_API_SUCCESS;
 542 }
 543
 544 EXPORT_API int tel_hold_call(TapiHandle *handle, unsigned int CallHandle, tapi_response_cb callback, void *user_data)
 545 {
 546         struct tapi_resp_data *evt_cb_data = 0;
 547         GVariant *param = 0;
 548
 549         TAPI_RET_ERR_NUM_IF_NOT_SUPPORTED(TELEPHONY_FEATURE);
 550         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 551
 552         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 553
 554         param = g_variant_new("(i)", CallHandle);
 555
 556         msg("[%s] Request Hold. call_handle:[%d]", handle->cp_name, CallHandle);
 557
 558         g_dbus_connection_call(handle->dbus_connection,
 559                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 560                         "Hold", param, 0,
 561                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 562                         on_response_call_hold, evt_cb_data);
 563
 564         return TAPI_API_SUCCESS;
 565 }
 566
 567 EXPORT_API int tel_active_call(TapiHandle *handle, unsigned int CallHandle, tapi_response_cb callback, void *user_data)
 568 {
 569         struct tapi_resp_data *evt_cb_data = 0;
 570         GVariant *param = 0;
 571
 572         TAPI_RET_ERR_NUM_IF_NOT_SUPPORTED(TELEPHONY_FEATURE);
 573         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 574
 575         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 576
 577         param = g_variant_new("(i)", CallHandle);
 578
 579         msg("[%s] Request Active. call_handle:[%d]", handle->cp_name, CallHandle);
 580
 581         g_dbus_connection_call(handle->dbus_connection,
 582                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 583                         "Active", param, 0,
 584                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 585                         on_response_call_active, evt_cb_data);
 586
 587         return TAPI_API_SUCCESS;
 588 }
 589
 590 EXPORT_API int tel_swap_call(TapiHandle *handle, unsigned int CallHandle1, unsigned int CallHandle2, tapi_response_cb callback, void *user_data)
 591 {
 592         struct tapi_resp_data *evt_cb_data = 0;
 593         GVariant *param = 0;
 594
 595         TAPI_RET_ERR_NUM_IF_NOT_SUPPORTED(TELEPHONY_FEATURE);
 596         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 597
 598         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 599
 600         param = g_variant_new("(i)", CallHandle1);
 601
 602         msg("[%s] Request Swap. call_handle:[%d][%d]", handle->cp_name, CallHandle1, CallHandle2);
 603
 604         g_dbus_connection_call(handle->dbus_connection,
 605                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 606                         "Swap", param, 0,
 607                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 608                         on_response_call_swap, evt_cb_data);
 609
 610         return TAPI_API_SUCCESS;
 611 }
 612
 613 EXPORT_API int tel_join_call(TapiHandle *handle, unsigned int CallHandle1, unsigned int CallHandle2, tapi_response_cb callback, void *user_data)
 614 {
 615         struct tapi_resp_data *evt_cb_data = 0;
 616         GVariant *param = 0;
 617
 618         TAPI_RET_ERR_NUM_IF_NOT_SUPPORTED(TELEPHONY_FEATURE);
 619         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 620
 621         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 622
 623         param = g_variant_new("(i)", CallHandle1);
 624
 625         msg("[%s] Request Join", handle->cp_name);
 626
 627         g_dbus_connection_call(handle->dbus_connection,
 628                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 629                         "Join", param, 0,
 630                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 631                         on_response_call_join, evt_cb_data);
 632
 633         return TAPI_API_SUCCESS;
 634 }
 635
 636 EXPORT_API int tel_split_call(TapiHandle *handle, unsigned int CallHandle, tapi_response_cb callback, void *user_data)
 637 {
 638         struct tapi_resp_data *evt_cb_data = 0;
 639         GVariant *param = 0;
 640
 641         TAPI_RET_ERR_NUM_IF_NOT_SUPPORTED(TELEPHONY_FEATURE);
 642         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 643
 644         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 645
 646         param = g_variant_new("(i)", CallHandle);
 647
 648         msg("[%s] Request Split. call_handle:[%d]", handle->cp_name, CallHandle);
 649
 650         g_dbus_connection_call(handle->dbus_connection,
 651                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 652                         "Split", param, 0,
 653                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 654                         on_response_call_split, evt_cb_data);
 655
 656         return TAPI_API_SUCCESS;
 657 }
 658
 659 EXPORT_API int tel_transfer_call(TapiHandle *handle, unsigned int CallHandle, tapi_response_cb callback, void *user_data)
 660 {
 661         struct tapi_resp_data *evt_cb_data = 0;
 662         GVariant *param = 0;
 663
 664         TAPI_RET_ERR_NUM_IF_NOT_SUPPORTED(TELEPHONY_FEATURE);
 665         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 666
 667         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 668
 669         param = g_variant_new("(i)", CallHandle);
 670
 671         msg("[%s] Request Transfer. call_handle:[%d]", handle->cp_name, CallHandle);
 672
 673         g_dbus_connection_call(handle->dbus_connection,
 674                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 675                         "Transfer", param, 0,
 676                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 677                         on_response_call_transfer, evt_cb_data);
 678
 679         return TAPI_API_SUCCESS;
 680 }
 681
 682 EXPORT_API int tel_start_call_cont_dtmf(TapiHandle *handle, unsigned char dtmf_digit, tapi_response_cb callback, void *user_data)
 683 {
 684         struct tapi_resp_data *evt_cb_data = 0;
 685         GVariant *param = 0;
 686
 687         TAPI_RET_ERR_NUM_IF_NOT_SUPPORTED(TELEPHONY_FEATURE);
 688         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 689
 690         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 691
 692         param = g_variant_new("(y)", dtmf_digit);
 693
 694         msg("[%s] Request cont DTMF", handle->cp_name);
 695
 696         g_dbus_connection_call(handle->dbus_connection,
 697                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 698                         "StartContDtmf", param, 0,
 699                         G_DBUS_CALL_FLAGS_NONE, G_MAXINT, handle->ca,
 700                         on_response_call_dtmf, evt_cb_data);
 701
 702         return TAPI_API_SUCCESS;
 703 }
 704
 705 EXPORT_API int tel_stop_call_cont_dtmf(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 706 {
 707         struct tapi_resp_data *evt_cb_data = 0;
 708
 709         TAPI_RET_ERR_NUM_IF_NOT_SUPPORTED(TELEPHONY_FEATURE);
 710         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 711
 712         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 713
 714         msg("[%s] Stop cont DTMF", handle->cp_name);
 715
 716         g_dbus_connection_call(handle->dbus_connection,
 717                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 718                         "StopContDtmf", NULL, 0,
 719                         G_DBUS_CALL_FLAGS_NONE, G_MAXINT, handle->ca,
 720                         on_response_call_dtmf, evt_cb_data);
 721
 722         return TAPI_API_SUCCESS;
 723 }
 724
 725 EXPORT_API int tel_send_call_burst_dtmf(TapiHandle *handle, const TelCallBurstDtmf_t *info, tapi_response_cb callback, void *user_data)
 726 {
 727         struct tapi_resp_data *evt_cb_data = 0;
 728         GVariant *param = 0;
 729
 730         TAPI_RET_ERR_NUM_IF_NOT_SUPPORTED(TELEPHONY_FEATURE);
 731         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 732         TAPI_RET_ERR_NUM_IF_FAIL(info, TAPI_API_INVALID_PTR);
 733
 734         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 735
 736         param = g_variant_new("(sii)", info->dtmf_string, info->pulse_width, info->inter_digit_interval);
 737
 738         msg("[%s] Send burst DTMF", handle->cp_name);
 739
 740         g_dbus_connection_call(handle->dbus_connection,
 741                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 742                         "SendBurstDtmf", param, 0,
 743                         G_DBUS_CALL_FLAGS_NONE, G_MAXINT, handle->ca,
 744                         on_response_call_dtmf, evt_cb_data);
 745
 746         return TAPI_API_SUCCESS;
 747 }
 748
 749 EXPORT_API int tel_deflect_call(TapiHandle *handle, unsigned int CallHandle, const TelCallDeflectDstInfo_t *pInfo, tapi_response_cb callback, void *user_data)
 750 {
 751         struct tapi_resp_data *evt_cb_data = 0;
 752         GVariant *param = 0;
 753
 754         TAPI_RET_ERR_NUM_IF_NOT_SUPPORTED(TELEPHONY_FEATURE);
 755         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 756         TAPI_RET_ERR_NUM_IF_FAIL(pInfo, TAPI_API_INVALID_PTR);
 757
 758         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 759
 760         param = g_variant_new("(is)", CallHandle, pInfo->number);
 761
 762         msg("[%s] deflect", handle->cp_name);
 763
 764         g_dbus_connection_call(handle->dbus_connection,
 765                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 766                         "Deflect", param, 0,
 767                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 768                         on_response_call_deflect, evt_cb_data);
 769
 770         return TAPI_API_SUCCESS;
 771 }
 772
 773 EXPORT_API int tel_get_call_status(TapiHandle *handle, int callHandle, TelCallStatus_t *out)
 774 {
 775         GVariant *gv = 0;
 776         GVariant *param = 0;
 777
 778         GError *gerr = 0;
 779
 780         gchar *call_number;
 781         gint call_type = 0;
 782         gboolean call_direction = FALSE;
 783         gint call_state = 0;
 784         gboolean call_multiparty_state = FALSE;
 785         gboolean volte_call = FALSE;
 786         gboolean is_hd_icon;
 787         gboolean is_modifiable;
 788         gboolean added_to_conference;
 789         gchar *audio_codec = NULL;
 790         gint id;
 791
 792         TAPI_RET_ERR_NUM_IF_NOT_SUPPORTED(TELEPHONY_FEATURE);
 793         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 794         TAPI_RET_ERR_NUM_IF_FAIL(out, TAPI_API_INVALID_PTR);
 795
 796         param = g_variant_new("(i)", callHandle);
 797
 798         dbg("[%s] Func Entrance ", handle->cp_name);
 799
 800         gv = g_dbus_connection_call_sync(handle->dbus_connection,
 801                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 802                         "GetStatus", param, 0, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca, &gerr);
 803
 804         if (gv) {
 805                 g_variant_get(gv, "(isibibbbbbsi)",  &callHandle,
 806                         &call_number, &call_type, &call_direction,
 807                         &call_state, &call_multiparty_state, &volte_call,
 808                         &is_hd_icon, &is_modifiable, &added_to_conference, &audio_codec, &id);
 809
 810                 out->CallHandle = (int)callHandle;
 811                 out->bMoCall = (int)call_direction;
 812                 strncpy(out->pNumber, call_number, TAPI_CALL_DIALDIGIT_LEN_MAX);
 813
 814                 dbg("[ check ] call_number : [%s] out->pNumber : [%s]", call_number, out->pNumber);
 815
 816                 out->CallType = (TelCallType_t)call_type;
 817                 out->CallState = (TelCallStates_t)call_state;
 818                 out->bConferenceState = (int)call_multiparty_state;
 819                 out->bVolteCall = (int)volte_call;
 820
 821                 g_free(call_number);
 822                 g_variant_unref(gv);
 823                 if (gerr)
 824                         g_error_free(gerr);
 825         } else {
 826                 dbg("[ error ] fail to get call status : (0x%x)", callHandle);
 827                 g_error_free(gerr);
 828                 return TAPI_API_OPERATION_FAILED;
 829         }
 830
 831         return TAPI_API_SUCCESS;
 832 }
 833
 834 EXPORT_API int tel_get_call_status_all(TapiHandle *handle, TelCallStatusCallback cb, void *user_data)
 835 {
 836         GVariant *gv = 0;
 837         GVariantIter *iter = 0, *iter_row = 0;
 838         GError *gerr = 0;
 839
 840         TAPI_RET_ERR_NUM_IF_NOT_SUPPORTED(TELEPHONY_FEATURE);
 841         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 842         TAPI_RET_ERR_NUM_IF_FAIL(cb, TAPI_API_INVALID_PTR);
 843
 844         dbg("[%s] Func Entrance ", handle->cp_name);
 845
 846         gv = g_dbus_connection_call_sync(handle->dbus_connection,
 847                 DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 848                 "GetStatusAll", 0, 0, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca, &gerr);
 849         if (gv) {
 850                 TelCallStatus_t data;
 851                 gchar *key = 0;
 852                 GVariant *value = 0;
 853
 854                 memset(&data, 0x0, sizeof(TelCallStatus_t));
 855                 g_variant_get(gv, "(aa{sv})", &iter);
 856
 857                 while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
 858                         while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
 859                                 if (!g_strcmp0(key, "call_id"))
 860                                         data.CallHandle = g_variant_get_int32(value);
 861                                 else if (!g_strcmp0(key, "call_number"))
 862                                         strncpy(data.pNumber, g_variant_get_string(value, 0), TAPI_CALL_DIALDIGIT_LEN_MAX);
 863                                 else if (!g_strcmp0(key, "call_type"))
 864                                         data.CallType = (int)g_variant_get_int32(value);
 865                                 else if (!g_strcmp0(key, "call_direction"))
 866                                         data.bMoCall = (int)g_variant_get_boolean(value);
 867                                 else if (!g_strcmp0(key, "call_state"))
 868                                         data.CallState = (int)g_variant_get_int32(value);
 869                                 else if (!g_strcmp0(key, "call_multiparty_state"))
 870                                         data.bConferenceState = (int)g_variant_get_boolean(value);
 871                                 else if (!g_strcmp0(key, "is_volte_call"))
 872                                         data.bVolteCall = (int)g_variant_get_boolean(value);
 873                         }
 874                         g_variant_iter_free(iter_row);
 875
 876                         cb(&data, user_data);
 877                 }
 878                 g_variant_iter_free(iter);
 879                 g_variant_unref(gv);
 880                 if (gerr)
 881                         g_error_free(gerr);
 882         } else {
 883                 if (strstr(gerr->message, "AccessDenied")) {
 884                         err("Permission denied");
 885                         return TAPI_API_ACCESS_DENIED;
 886                 } else {
 887                         err("[error] fail to get call status (%s)", gerr->message);
 888                         return TAPI_API_OPERATION_FAILED;
 889                 }
 890         }
 891
 892         return TAPI_API_SUCCESS;
 893 }
 894
 895 EXPORT_API int tel_get_call_privacy_mode(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 896 {
 897         struct tapi_resp_data *evt_cb_data = 0;
 898
 899         TAPI_RET_ERR_NUM_IF_NOT_SUPPORTED(TELEPHONY_FEATURE);
 900         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 901
 902         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 903
 904         dbg("[%s] Func Entrance ", handle->cp_name);
 905
 906         g_dbus_connection_call(handle->dbus_connection,
 907                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 908                         "GetPrivacyMode", 0, 0,
 909                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 910                         on_response_get_call_privacy_mode, evt_cb_data);
 911
 912         return TAPI_API_SUCCESS;
 913 }
 914
 915 EXPORT_API int tel_set_call_privacy_mode(TapiHandle *handle, TelCallPrivacyMode_t privacy_mode, tapi_response_cb callback, void *user_data)
 916 {
 917         struct tapi_resp_data *evt_cb_data = 0;
 918         GVariant *pParam = 0;
 919
 920         TAPI_RET_ERR_NUM_IF_NOT_SUPPORTED(TELEPHONY_FEATURE);
 921         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 922
 923         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 924
 925         pParam = g_variant_new("(i)", privacy_mode);
 926
 927         msg("[%s] Set Privacy. mode:[%d]", handle->cp_name, privacy_mode);
 928
 929         g_dbus_connection_call(handle->dbus_connection,
 930                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 931                         "SetPrivacyMode", pParam, 0,
 932                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 933                         on_response_set_call_privacy_mode, evt_cb_data);
 934
 935         return TAPI_API_SUCCESS;
 936 }
 937
 938 EXPORT_API int tel_get_call_volume_info(TapiHandle *handle, TelSoundDevice_t device, TelSoundType_t type, tapi_response_cb callback, void *user_data)
 939 {
 940         struct tapi_resp_data *evt_cb_data = 0;
 941         GVariant *param = 0;
 942
 943         TAPI_RET_ERR_NUM_IF_NOT_SUPPORTED(TELEPHONY_FEATURE);
 944         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 945
 946         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 947
 948         param = g_variant_new("(ii)", device, type);
 949
 950         dbg("[%s] Get Volume Info. device:[%d] type:[%d] ", handle->cp_name, device, type);
 951
 952         g_dbus_connection_call(handle->dbus_connection,
 953                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 954                         "GetSoundVolumeLevel", param, 0,
 955                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 956                         on_response_get_call_volume_info, evt_cb_data);
 957
 958         return TAPI_API_SUCCESS;
 959 }
 960
 961 EXPORT_API int tel_set_call_volume_info(TapiHandle *handle, TelCallVolumeInfo_t *info, tapi_response_cb callback, void *user_data)
 962 {
 963         struct tapi_resp_data *evt_cb_data = 0;
 964         GVariant *param = 0;
 965
 966         TAPI_RET_ERR_NUM_IF_NOT_SUPPORTED(TELEPHONY_FEATURE);
 967         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 968         TAPI_RET_ERR_NUM_IF_FAIL(info, TAPI_API_INVALID_PTR);
 969
 970         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 971
 972         param = g_variant_new("(iii)", info->device, info->type, info->volume);
 973
 974         dbg("[%s] Set Volume Info. device:[%d] type:[%d] volume:[%d] ",
 975                 handle->cp_name, info->device, info->type, info->volume);
 976
 977         g_dbus_connection_call(handle->dbus_connection,
 978                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 979                         "SetSoundVolumeLevel", param, 0,
 980                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 981                         on_response_set_call_volume_info, evt_cb_data);
 982
 983         return TAPI_API_SUCCESS;
 984 }
 985
 986 EXPORT_API int tel_set_call_sound_path(TapiHandle *handle, TelCallSoundPathInfo_t *info, tapi_response_cb callback, void *user_data)
 987 {
 988         struct tapi_resp_data *evt_cb_data = 0;
 989         GVariant *param = 0;
 990
 991         TAPI_RET_ERR_NUM_IF_NOT_SUPPORTED(TELEPHONY_FEATURE);
 992         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 993         TAPI_RET_ERR_NUM_IF_FAIL(info, TAPI_API_INVALID_PTR);
 994
 995         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 996
 997         param = g_variant_new("(ib)", info->path, info->ex_volume);
 998
 999         dbg("[%s] Set Sound Path. path:[%d] ex_volume:[%d]", handle->cp_name, info->path, info->ex_volume);
1000
1001         g_dbus_connection_call(handle->dbus_connection,
1002                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
1003                         "SetSoundPath", param, 0,
1004                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1005                         on_response_set_call_sound_path, evt_cb_data);
1006
1007         return TAPI_API_SUCCESS;
1008 }
1009
1010 EXPORT_API int tel_set_call_mute_status(TapiHandle *handle, TelSoundMuteStatus_t mute, TelSoundMutePath_t path, tapi_response_cb callback, void *user_data)
1011 {
1012         struct tapi_resp_data *evt_cb_data = 0;
1013         GVariant *param = 0;
1014
1015         TAPI_RET_ERR_NUM_IF_NOT_SUPPORTED(TELEPHONY_FEATURE);
1016         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1017
1018         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1019
1020         param = g_variant_new("(ii)", mute, path);
1021
1022         dbg("[%s] Set Mute. mute:[%d] path:[%d] ", handle->cp_name, mute, path);
1023
1024         g_dbus_connection_call(handle->dbus_connection,
1025                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
1026                         "SetSoundMuteStatus", param, 0,
1027                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1028                         on_response_set_call_mute_status, evt_cb_data);
1029
1030         return TAPI_API_SUCCESS;
1031 }
1032
1033 EXPORT_API int tel_get_call_mute_status(TapiHandle *handle, tapi_response_cb callback, void *user_data)
1034 {
1035         struct tapi_resp_data *evt_cb_data = 0;
1036
1037         TAPI_RET_ERR_NUM_IF_NOT_SUPPORTED(TELEPHONY_FEATURE);
1038         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1039         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
1040
1041         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1042
1043         dbg("[%s] Func Entrance ", handle->cp_name);
1044
1045         g_dbus_connection_call(handle->dbus_connection,
1046                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
1047                         "GetSoundMuteStatus", 0, 0,
1048                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1049                         on_response_get_call_mute_status, evt_cb_data);
1050
1051         return TAPI_API_SUCCESS;
1052 }
1053
1054 EXPORT_API int tel_set_call_preferred_voice_subscription(TapiHandle *handle, TelCallPreferredVoiceSubs_t preferred_subscription,
1055         tapi_response_cb callback, void *user_data)
1056 {
1057         struct tapi_resp_data *evt_cb_data = NULL;
1058         GVariant *param = NULL;
1059
1060         TAPI_RET_ERR_NUM_IF_NOT_SUPPORTED(TELEPHONY_FEATURE);
1061         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1062         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
1063
1064         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1065
1066         param = g_variant_new("(i)", preferred_subscription);
1067
1068         dbg("[%s] Set Preferred Voice. subs:[%d]", handle->cp_name, preferred_subscription);
1069
1070         /* DBUS call */
1071         g_dbus_connection_call(handle->dbus_connection,
1072                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
1073                         "SetPreferredVoiceSubscription", param, NULL,
1074                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1075                         on_response_set_preferred_voice_subscription, evt_cb_data);
1076
1077         return TAPI_API_SUCCESS;
1078 }
1079
1080 EXPORT_API int tel_get_call_preferred_voice_subscription(TapiHandle *handle, TelCallPreferredVoiceSubs_t *preferred_subscription)
1081 {
1082         GError *gerr = NULL;
1083         GVariant *sync_gv = NULL;
1084         int subs = 0;
1085         int result = 0;
1086         TapiResult_t ret = TAPI_API_OPERATION_FAILED;
1087
1088         TAPI_RET_ERR_NUM_IF_NOT_SUPPORTED(TELEPHONY_FEATURE);
1089         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1090         TAPI_RET_ERR_NUM_IF_FAIL(preferred_subscription, TAPI_API_INVALID_PTR);
1091
1092         sync_gv = g_dbus_connection_call_sync(handle->dbus_connection,
1093                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
1094                         "GetPreferredVoiceSubscription", NULL, NULL,
1095                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1096                         &gerr);
1097         if (sync_gv) {
1098                 g_variant_get(sync_gv, "(ii)", &subs, &result);
1099
1100                 if (result == 0)
1101                         *preferred_subscription = subs;
1102                 else
1103                         *preferred_subscription = TAPI_CALL_PREFERRED_VOICE_SUBS_UNKNOWN;
1104                 dbg("'preferred' Voice Subscription: [%d]", subs);
1105
1106                 ret = TAPI_API_SUCCESS;
1107                 g_variant_unref(sync_gv);
1108         } else {
1109                 err("Get 'preferred' Voice Subscription failed: [%s]", gerr->message);
1110                 if (strstr(gerr->message, "AccessDenied"))
1111                         ret = TAPI_API_ACCESS_DENIED;
1112                 g_error_free(gerr);
1113         }
1114
1115         return ret;
1116 }