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