wearable/src/tapi_call.c

   1 /*
   2  * libslp-tapi
   3  *
   4  * Copyright (c) 2011 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_DEINIT(error);
  45
  46         if (!dbus_result) {
  47                 if (evt_cb_data->cb_fn)
  48                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
  49
  50                 if (error)
  51                         g_error_free(error);
  52
  53                 g_free(evt_cb_data);
  54                 return;
  55         }
  56
  57         g_variant_get (dbus_result, "(i)", &result);
  58
  59         if (evt_cb_data->cb_fn)
  60                 evt_cb_data->cb_fn(evt_cb_data->handle, result, 0, evt_cb_data->user_data);
  61
  62         g_free(evt_cb_data);
  63 }
  64
  65 static void on_response_call_answer(GObject *source_object, GAsyncResult *res, gpointer user_data)
  66 {
  67         GError *error = 0;
  68         GDBusConnection *conn = 0;
  69         struct tapi_resp_data *evt_cb_data = user_data;
  70         int result = -1;
  71         TelCallAnswerCnf_t data;
  72
  73         GVariant *dbus_result;
  74
  75         conn = G_DBUS_CONNECTION (source_object);
  76         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
  77         CHECK_DEINIT(error);
  78
  79         if (!dbus_result) {
  80                 if (evt_cb_data->cb_fn)
  81                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
  82
  83                 if (error)
  84                         g_error_free(error);
  85
  86                 g_free(evt_cb_data);
  87                 return;
  88         }
  89
  90         g_variant_get (dbus_result, "(ii)", &result, &data.id);
  91
  92         if (evt_cb_data->cb_fn)
  93                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
  94
  95         g_free(evt_cb_data);
  96 }
  97
  98 static void on_response_call_end(GObject *source_object, GAsyncResult *res, gpointer user_data)
  99 {
 100         GError *error = 0;
 101         GDBusConnection *conn = 0;
 102         struct tapi_resp_data *evt_cb_data = user_data;
 103         int result = -1;
 104         TelCallEndCnf_t data;
 105
 106         GVariant *dbus_result;
 107
 108         conn = G_DBUS_CONNECTION (source_object);
 109         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 110         CHECK_DEINIT(error);
 111
 112         if (!dbus_result) {
 113                 if (evt_cb_data->cb_fn)
 114                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 115
 116                 if (error)
 117                         g_error_free(error);
 118
 119                 g_free(evt_cb_data);
 120                 return;
 121         }
 122
 123         g_variant_get (dbus_result, "(iii)", &result, &data.id, &data.type);
 124
 125         if (evt_cb_data->cb_fn)
 126                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
 127
 128         g_free(evt_cb_data);
 129 }
 130
 131 static void on_response_call_hold(GObject *source_object, GAsyncResult *res, gpointer user_data)
 132 {
 133         GError *error = 0;
 134         GDBusConnection *conn = 0;
 135         struct tapi_resp_data *evt_cb_data = user_data;
 136         int result = -1;
 137         TelCallHoldCnf_t data;
 138
 139         GVariant *dbus_result;
 140
 141         conn = G_DBUS_CONNECTION (source_object);
 142         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 143         CHECK_DEINIT(error);
 144
 145         if (!dbus_result) {
 146                 if (evt_cb_data->cb_fn)
 147                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 148
 149                 if (error)
 150                         g_error_free(error);
 151
 152                 g_free(evt_cb_data);
 153                 return;
 154         }
 155
 156         g_variant_get (dbus_result, "(ii)", &result, &data.id);
 157
 158         if (evt_cb_data->cb_fn)
 159                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
 160
 161         g_free(evt_cb_data);
 162 }
 163
 164 static void on_response_call_active(GObject *source_object, GAsyncResult *res, gpointer user_data)
 165 {
 166         GError *error = 0;
 167         GDBusConnection *conn = 0;
 168         struct tapi_resp_data *evt_cb_data = user_data;
 169         int result = -1;
 170         TelCallActiveCnf_t data;
 171
 172         GVariant *dbus_result;
 173
 174         conn = G_DBUS_CONNECTION (source_object);
 175         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 176         CHECK_DEINIT(error);
 177
 178         if (!dbus_result) {
 179                 if (evt_cb_data->cb_fn)
 180                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 181
 182                 if (error)
 183                         g_error_free(error);
 184
 185                 g_free(evt_cb_data);
 186                 return;
 187         }
 188
 189         g_variant_get (dbus_result, "(ii)", &result, &data.id);
 190
 191         if (evt_cb_data->cb_fn)
 192                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
 193
 194         g_free(evt_cb_data);
 195 }
 196
 197 static void on_response_call_swap(GObject *source_object, GAsyncResult *res, gpointer user_data)
 198 {
 199         GError *error = 0;
 200         GDBusConnection *conn = 0;
 201         struct tapi_resp_data *evt_cb_data = user_data;
 202         int result = -1;
 203         TelCallSwapCnf_t data;
 204
 205         GVariant *dbus_result;
 206
 207         conn = G_DBUS_CONNECTION (source_object);
 208         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 209         CHECK_DEINIT(error);
 210
 211         if (!dbus_result) {
 212                 if (evt_cb_data->cb_fn)
 213                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 214
 215                 if (error)
 216                         g_error_free(error);
 217
 218                 g_free(evt_cb_data);
 219                 return;
 220         }
 221
 222         g_variant_get (dbus_result, "(ii)", &result, &data.id);
 223
 224         if (evt_cb_data->cb_fn)
 225                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
 226
 227         g_free(evt_cb_data);
 228 }
 229
 230 static void on_response_call_join(GObject *source_object, GAsyncResult *res, gpointer user_data)
 231 {
 232         GError *error = 0;
 233         GDBusConnection *conn = 0;
 234         struct tapi_resp_data *evt_cb_data = user_data;
 235         int result = -1;
 236         TelCallJoinCnf_t data;
 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         CHECK_DEINIT(error);
 243
 244         if (!dbus_result) {
 245                 if (evt_cb_data->cb_fn)
 246                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 247
 248                 if (error)
 249                         g_error_free(error);
 250
 251                 g_free(evt_cb_data);
 252                 return;
 253         }
 254
 255         g_variant_get (dbus_result, "(ii)", &result, &data.id);
 256
 257         if (evt_cb_data->cb_fn)
 258                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
 259
 260         g_free(evt_cb_data);
 261 }
 262
 263 static void on_response_call_split(GObject *source_object, GAsyncResult *res, gpointer user_data)
 264 {
 265         GError *error = 0;
 266         GDBusConnection *conn = 0;
 267         struct tapi_resp_data *evt_cb_data = user_data;
 268         int result = -1;
 269         TelCallSplitCnf_t data;
 270
 271         GVariant *dbus_result;
 272
 273         conn = G_DBUS_CONNECTION (source_object);
 274         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 275         CHECK_DEINIT(error);
 276
 277         if (!dbus_result) {
 278                 if (evt_cb_data->cb_fn)
 279                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 280
 281                 if (error)
 282                         g_error_free(error);
 283
 284                 g_free(evt_cb_data);
 285                 return;
 286         }
 287
 288         g_variant_get (dbus_result, "(ii)", &result, &data.id);
 289
 290         if (evt_cb_data->cb_fn)
 291                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
 292
 293         g_free(evt_cb_data);
 294 }
 295
 296 static void on_response_call_transfer(GObject *source_object, GAsyncResult *res, gpointer user_data)
 297 {
 298         GError *error = 0;
 299         GDBusConnection *conn = 0;
 300         struct tapi_resp_data *evt_cb_data = user_data;
 301         int result = -1;
 302         TelCallTransferCnf_t data;
 303
 304         GVariant *dbus_result;
 305
 306         conn = G_DBUS_CONNECTION (source_object);
 307         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 308         CHECK_DEINIT(error);
 309
 310         if (!dbus_result) {
 311                 if (evt_cb_data->cb_fn)
 312                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 313
 314                 if (error)
 315                         g_error_free(error);
 316
 317                 g_free(evt_cb_data);
 318                 return;
 319         }
 320
 321         g_variant_get (dbus_result, "(ii)", &result, &data.id);
 322
 323         if (evt_cb_data->cb_fn)
 324                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
 325
 326         g_free(evt_cb_data);
 327 }
 328
 329 static void on_response_call_dtmf(GObject *source_object, GAsyncResult *res, gpointer user_data)
 330 {
 331         GError *error = 0;
 332         GDBusConnection *conn = 0;
 333         struct tapi_resp_data *evt_cb_data = user_data;
 334         int result = -1;
 335
 336         GVariant *dbus_result;
 337
 338         conn = G_DBUS_CONNECTION (source_object);
 339         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 340         CHECK_DEINIT(error);
 341
 342         if (!dbus_result) {
 343                 if (evt_cb_data->cb_fn)
 344                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 345
 346                 if (error)
 347                         g_error_free(error);
 348
 349                 g_free(evt_cb_data);
 350                 return;
 351         }
 352
 353         g_variant_get (dbus_result, "(i)", &result);
 354
 355         if (evt_cb_data->cb_fn)
 356                 evt_cb_data->cb_fn(evt_cb_data->handle, result, 0, evt_cb_data->user_data);
 357
 358         g_free(evt_cb_data);
 359 }
 360
 361 static void on_response_call_deflect(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         CHECK_DEINIT(error);
 373
 374         if (!dbus_result) {
 375                 if (evt_cb_data->cb_fn)
 376                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 377
 378                 if (error)
 379                         g_error_free(error);
 380
 381                 g_free(evt_cb_data);
 382                 return;
 383         }
 384
 385         g_variant_get (dbus_result, "(i)", &result);
 386
 387         if (evt_cb_data->cb_fn)
 388                 evt_cb_data->cb_fn(evt_cb_data->handle, result, 0, evt_cb_data->user_data);
 389
 390         g_free(evt_cb_data);
 391 }
 392
 393 static void on_response_get_call_volume_info(GObject *source_object, GAsyncResult *res, gpointer user_data)
 394 {
 395         GError *error = 0;
 396         GDBusConnection *conn = 0;
 397         struct tapi_resp_data *evt_cb_data = user_data;
 398         int result = -1, i = 0;
 399         TelCallGetVolumeInfoResp_t resp;
 400
 401         GVariant *dbus_result = 0, *value = 0;
 402         GVariantIter *iter = 0;
 403         GVariantIter *iter_row = 0;
 404         const gchar *key = 0;
 405
 406         memset(&resp, '\0', sizeof(TelCallGetVolumeInfoResp_t));
 407
 408         conn = G_DBUS_CONNECTION (source_object);
 409         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 410         CHECK_DEINIT(error);
 411
 412         if (!dbus_result) {
 413                 if (evt_cb_data->cb_fn)
 414                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 415
 416                 if (error)
 417                         g_error_free(error);
 418
 419                 g_free(evt_cb_data);
 420                 return;
 421         }
 422
 423         g_variant_get (dbus_result, "(aa{sv}i)", &iter, &result);
 424
 425         resp.record_num = g_variant_iter_n_children(iter);
 426
 427         while ( g_variant_iter_next(iter, "a{sv}", &iter_row ) ) {
 428                 while ( g_variant_iter_loop( iter_row, "{sv}", &key, &value ) ) {
 429
 430                         if ( !g_strcmp0(key, "type") ) {
 431                                 int type = g_variant_get_int32(value);
 432
 433                                 resp.record[i].device = (type & 0xf0);
 434                                 resp.record[i].type = (type & 0x0f);
 435                         }
 436
 437                         if ( !g_strcmp0(key, "level") ) {
 438                                 resp.record[i].volume = g_variant_get_int32(value);
 439                         }
 440                 }
 441                 i++;
 442                 g_variant_iter_free(iter_row);
 443         }
 444         g_variant_iter_free(iter);
 445
 446         if (evt_cb_data->cb_fn)
 447                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &resp, evt_cb_data->user_data);
 448
 449         g_free(evt_cb_data);
 450 }
 451
 452 static void on_response_set_call_volume_info(GObject *source_object, GAsyncResult *res, gpointer user_data)
 453 {
 454         GError *error = 0;
 455         GDBusConnection *conn = 0;
 456         struct tapi_resp_data *evt_cb_data = user_data;
 457         int result = -1;
 458
 459         GVariant *dbus_result;
 460
 461         conn = G_DBUS_CONNECTION (source_object);
 462         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 463         CHECK_DEINIT(error);
 464
 465         if (!dbus_result) {
 466                 if (evt_cb_data->cb_fn)
 467                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 468
 469                 if (error)
 470                         g_error_free(error);
 471
 472                 g_free(evt_cb_data);
 473                 return;
 474         }
 475
 476         g_variant_get (dbus_result, "(i)", &result);
 477
 478         if (evt_cb_data->cb_fn)
 479                 evt_cb_data->cb_fn(evt_cb_data->handle, result, 0, evt_cb_data->user_data);
 480
 481         g_free(evt_cb_data);
 482 }
 483
 484 static void on_response_set_call_sound_path(GObject *source_object, GAsyncResult *res, gpointer user_data)
 485 {
 486         GError *error = 0;
 487         GDBusConnection *conn = 0;
 488         struct tapi_resp_data *evt_cb_data = user_data;
 489         int result = -1;
 490
 491         GVariant *dbus_result;
 492
 493         conn = G_DBUS_CONNECTION (source_object);
 494         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 495         CHECK_DEINIT(error);
 496
 497         if (!dbus_result) {
 498                 if (evt_cb_data->cb_fn)
 499                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 500
 501                 if (error)
 502                         g_error_free(error);
 503
 504                 g_free(evt_cb_data);
 505                 return;
 506         }
 507
 508         g_variant_get (dbus_result, "(i)", &result);
 509
 510         if (evt_cb_data->cb_fn)
 511                 evt_cb_data->cb_fn(evt_cb_data->handle, result, 0, evt_cb_data->user_data);
 512
 513         g_free(evt_cb_data);
 514 }
 515
 516 static void on_response_set_call_mute_status(GObject *source_object, GAsyncResult *res, gpointer user_data)
 517 {
 518         GError *error = 0;
 519         GDBusConnection *conn = 0;
 520         struct tapi_resp_data *evt_cb_data = user_data;
 521         int result = -1;
 522
 523         GVariant *dbus_result;
 524
 525         conn = G_DBUS_CONNECTION (source_object);
 526         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 527         CHECK_DEINIT(error);
 528
 529         if (!dbus_result) {
 530                 if (evt_cb_data->cb_fn)
 531                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 532
 533                 if (error)
 534                         g_error_free(error);
 535
 536                 g_free(evt_cb_data);
 537                 return;
 538         }
 539
 540         g_variant_get (dbus_result, "(i)", &result);
 541
 542         if (evt_cb_data->cb_fn)
 543                 evt_cb_data->cb_fn(evt_cb_data->handle, result, 0, evt_cb_data->user_data);
 544
 545         g_free(evt_cb_data);
 546 }
 547
 548 static void on_response_get_call_mute_status(GObject *source_object, GAsyncResult *res, gpointer user_data)
 549 {
 550         GError *error = 0;
 551         GDBusConnection *conn = 0;
 552         struct tapi_resp_data *evt_cb_data = user_data;
 553         int result = -1;
 554         TelCallGetMuteStatusResp_t resp;
 555
 556         GVariant *dbus_result;
 557
 558         conn = G_DBUS_CONNECTION (source_object);
 559         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 560         CHECK_DEINIT(error);
 561
 562         if (!dbus_result) {
 563                 if (evt_cb_data->cb_fn)
 564                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 565
 566                 if (error)
 567                         g_error_free(error);
 568
 569                 g_free(evt_cb_data);
 570                 return;
 571         }
 572
 573         g_variant_get (dbus_result, "(iii)", &result, &resp.path, &resp.status);
 574
 575         if (evt_cb_data->cb_fn)
 576                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &resp, evt_cb_data->user_data);
 577
 578         g_free(evt_cb_data);
 579 }
 580
 581 static void on_response_set_call_sound_recording(GObject *source_object, GAsyncResult *res, gpointer user_data)
 582 {
 583         GError *error = 0;
 584         GDBusConnection *conn = 0;
 585         struct tapi_resp_data *evt_cb_data = user_data;
 586         int result = -1;
 587
 588         GVariant *dbus_result;
 589
 590         conn = G_DBUS_CONNECTION (source_object);
 591         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 592         CHECK_DEINIT(error);
 593
 594         if (!dbus_result) {
 595                 if (evt_cb_data->cb_fn)
 596                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 597
 598                 if (error)
 599                         g_error_free(error);
 600
 601                 g_free(evt_cb_data);
 602                 return;
 603         }
 604
 605         g_variant_get (dbus_result, "(i)", &result);
 606
 607         if (evt_cb_data->cb_fn)
 608                 evt_cb_data->cb_fn(evt_cb_data->handle, result, 0, evt_cb_data->user_data);
 609
 610         g_free(evt_cb_data);
 611 }
 612
 613 static void on_response_set_call_sound_equalization(GObject *source_object, GAsyncResult *res, gpointer user_data)
 614 {
 615         GError *error = 0;
 616         GDBusConnection *conn = 0;
 617         struct tapi_resp_data *evt_cb_data = user_data;
 618         int result = -1;
 619
 620         GVariant *dbus_result;
 621
 622         conn = G_DBUS_CONNECTION (source_object);
 623         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 624         CHECK_DEINIT(error);
 625
 626         if (!dbus_result) {
 627                 if (evt_cb_data->cb_fn)
 628                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 629
 630                 if (error)
 631                         g_error_free(error);
 632
 633                 g_free(evt_cb_data);
 634                 return;
 635         }
 636
 637         g_variant_get (dbus_result, "(i)", &result);
 638
 639         if (evt_cb_data->cb_fn)
 640                 evt_cb_data->cb_fn(evt_cb_data->handle, result, 0, evt_cb_data->user_data);
 641
 642         g_free(evt_cb_data);
 643 }
 644
 645 static void on_response_set_call_sound_noise_reduction(GObject *source_object, GAsyncResult *res, gpointer user_data)
 646 {
 647         GError *error = 0;
 648         GDBusConnection *conn = 0;
 649         struct tapi_resp_data *evt_cb_data = user_data;
 650         int result = -1;
 651
 652         GVariant *dbus_result;
 653
 654         conn = G_DBUS_CONNECTION (source_object);
 655         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 656         CHECK_DEINIT(error);
 657
 658         if (!dbus_result) {
 659                 if (evt_cb_data->cb_fn)
 660                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 661
 662                 if (error)
 663                         g_error_free(error);
 664
 665                 g_free(evt_cb_data);
 666                 return;
 667         }
 668
 669         g_variant_get (dbus_result, "(i)", &result);
 670
 671         if (evt_cb_data->cb_fn)
 672                 evt_cb_data->cb_fn(evt_cb_data->handle, result, 0, evt_cb_data->user_data);
 673
 674         g_free(evt_cb_data);
 675 }
 676
 677 static void on_response_set_call_sound_clock_status(GObject *source_object, GAsyncResult *res, gpointer user_data)
 678 {
 679         GError *error = 0;
 680         GDBusConnection *conn = 0;
 681         struct tapi_resp_data *evt_cb_data = user_data;
 682         int result = -1;
 683
 684         GVariant *dbus_result;
 685
 686         conn = G_DBUS_CONNECTION (source_object);
 687         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 688         CHECK_DEINIT(error);
 689
 690         if (!dbus_result) {
 691                 if (evt_cb_data->cb_fn)
 692                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 693
 694                 if (error)
 695                         g_error_free(error);
 696
 697                 g_free(evt_cb_data);
 698                 return;
 699         }
 700
 701         g_variant_get (dbus_result, "(i)", &result);
 702
 703         if (evt_cb_data->cb_fn)
 704                 evt_cb_data->cb_fn(evt_cb_data->handle, result, 0, evt_cb_data->user_data);
 705
 706         g_free(evt_cb_data);
 707 }
 708
 709
 710 EXPORT_API int tel_dial_call(TapiHandle *handle, const TelCallDial_t *pParams, tapi_response_cb callback, void *user_data)
 711 {
 712         struct tapi_resp_data *evt_cb_data = 0;
 713         GVariant *param = 0;
 714
 715         dbg("Func Entrance ");
 716
 717         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 718         TAPI_RET_ERR_NUM_IF_FAIL(pParams, TAPI_API_INVALID_PTR);
 719
 720         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 721
 722         param = g_variant_new("(iis)", pParams->CallType, pParams->Ecc, pParams->szNumber);
 723
 724         g_dbus_connection_call(handle->dbus_connection,
 725                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 726                         "Dial", param, 0,
 727                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 728                         on_response_call_dial, evt_cb_data );
 729
 730         return TAPI_API_SUCCESS;
 731 }
 732
 733
 734 EXPORT_API int tel_answer_call(TapiHandle *handle, unsigned int CallHandle, TelCallAnswerType_t AnsType, tapi_response_cb callback, void *user_data )
 735 {
 736         struct tapi_resp_data *evt_cb_data = 0;
 737         GVariant *param = 0;
 738
 739         dbg("Func Entrance ");
 740
 741         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 742
 743         if (AnsType > TAPI_CALL_ANSWER_HOLD_AND_ACCEPT)
 744                 return TAPI_API_INVALID_INPUT;
 745
 746         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 747
 748         param = g_variant_new("(ii)", CallHandle, AnsType);
 749
 750         g_dbus_connection_call(handle->dbus_connection,
 751                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 752                         "Answer", param, 0,
 753                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 754                         on_response_call_answer, evt_cb_data );
 755
 756         return TAPI_API_SUCCESS;
 757 }
 758
 759 EXPORT_API int tel_end_call(TapiHandle *handle, unsigned int CallHandle, TelCallEndType_t EndType, tapi_response_cb callback, void *user_data)
 760 {
 761         struct tapi_resp_data *evt_cb_data = 0;
 762         GVariant *param = 0;
 763
 764         dbg("Func Entrance ");
 765
 766         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 767
 768         if (EndType > TAPI_CALL_END_HOLD_ALL)
 769                 return TAPI_API_INVALID_INPUT;
 770
 771         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 772
 773         param = g_variant_new("(ii)", CallHandle, EndType);
 774
 775         g_dbus_connection_call(handle->dbus_connection,
 776                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 777                         "End", param, 0,
 778                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 779                         on_response_call_end, evt_cb_data );
 780
 781         return TAPI_API_SUCCESS;
 782 }
 783
 784 EXPORT_API int tel_hold_call(TapiHandle *handle, unsigned int CallHandle, tapi_response_cb callback, void *user_data )
 785 {
 786         struct tapi_resp_data *evt_cb_data = 0;
 787         GVariant *param = 0;
 788
 789         dbg("Func Entrance ");
 790
 791         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 792
 793         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 794
 795         param = g_variant_new("(i)", CallHandle);
 796
 797         g_dbus_connection_call(handle->dbus_connection,
 798                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 799                         "Hold", param, 0,
 800                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 801                         on_response_call_hold, evt_cb_data );
 802
 803         return TAPI_API_SUCCESS;
 804 }
 805
 806 EXPORT_API int tel_active_call(TapiHandle *handle, unsigned int CallHandle, tapi_response_cb callback, void *user_data )
 807 {
 808         struct tapi_resp_data *evt_cb_data = 0;
 809         GVariant *param = 0;
 810
 811         dbg("Func Entrance ");
 812
 813         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 814
 815         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 816
 817         param = g_variant_new("(i)", CallHandle);
 818
 819         g_dbus_connection_call(handle->dbus_connection,
 820                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 821                         "Active", param, 0,
 822                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 823                         on_response_call_active, evt_cb_data );
 824
 825         return TAPI_API_SUCCESS;
 826 }
 827
 828 EXPORT_API int tel_swap_call(TapiHandle *handle, unsigned int CallHandle1, unsigned int CallHandle2, tapi_response_cb callback, void *user_data )
 829 {
 830         struct tapi_resp_data *evt_cb_data = 0;
 831         GVariant *param = 0;
 832
 833         dbg("Func Entrance ");
 834
 835         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 836
 837         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 838
 839         param = g_variant_new("(i)", CallHandle1);
 840
 841         g_dbus_connection_call(handle->dbus_connection,
 842                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 843                         "Swap", param, 0,
 844                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 845                         on_response_call_swap, evt_cb_data );
 846
 847         return TAPI_API_SUCCESS;
 848 }
 849
 850 EXPORT_API int tel_join_call(TapiHandle *handle, unsigned int CallHandle1, unsigned int CallHandle2, tapi_response_cb callback, void *user_data )
 851 {
 852         struct tapi_resp_data *evt_cb_data = 0;
 853         GVariant *param = 0;
 854
 855         dbg("Func Entrance ");
 856
 857         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 858
 859         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 860
 861         param = g_variant_new("(i)", CallHandle1);
 862
 863         g_dbus_connection_call(handle->dbus_connection,
 864                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 865                         "Join", param, 0,
 866                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 867                         on_response_call_join, evt_cb_data );
 868
 869         return TAPI_API_SUCCESS;
 870 }
 871
 872 EXPORT_API int tel_split_call(TapiHandle *handle, unsigned int CallHandle, tapi_response_cb callback, void *user_data )
 873 {
 874         struct tapi_resp_data *evt_cb_data = 0;
 875         GVariant *param = 0;
 876
 877         dbg("Func Entrance ");
 878
 879         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 880
 881         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 882
 883         param = g_variant_new("(i)", CallHandle);
 884
 885         g_dbus_connection_call(handle->dbus_connection,
 886                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 887                         "Split", param, 0,
 888                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 889                         on_response_call_split, evt_cb_data );
 890
 891         return TAPI_API_SUCCESS;
 892 }
 893
 894 EXPORT_API int tel_transfer_call(TapiHandle *handle, unsigned int CallHandle, tapi_response_cb callback, void *user_data )
 895 {
 896         struct tapi_resp_data *evt_cb_data = 0;
 897         GVariant *param = 0;
 898
 899         dbg("Func Entrance ");
 900
 901         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 902
 903         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 904
 905         param = g_variant_new("(i)", CallHandle);
 906
 907         g_dbus_connection_call(handle->dbus_connection,
 908                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 909                         "Transfer", param, 0,
 910                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 911                         on_response_call_transfer, evt_cb_data );
 912
 913         return TAPI_API_SUCCESS;
 914 }
 915
 916 EXPORT_API int tel_activate_call_ccbs(TapiHandle *handle, unsigned int CallHandle, tapi_response_cb callback, void *user_data )
 917 {
 918         return TAPI_API_SUCCESS;
 919 }
 920
 921 EXPORT_API int tel_call_dtmf(TapiHandle *handle, const char *pDtmfString, tapi_response_cb callback, void *user_data )
 922 {
 923         struct tapi_resp_data *evt_cb_data = 0;
 924         GVariant *param = 0;
 925
 926         dbg("Func Entrance ");
 927
 928         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 929         TAPI_RET_ERR_NUM_IF_FAIL(pDtmfString, TAPI_API_INVALID_PTR);
 930
 931         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 932
 933         param = g_variant_new("(s)", pDtmfString);
 934
 935         g_dbus_connection_call(handle->dbus_connection,
 936                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 937                         "Dtmf", param, 0,
 938                         G_DBUS_CALL_FLAGS_NONE, G_MAXINT, handle->ca,
 939                         on_response_call_dtmf, evt_cb_data );
 940
 941         return TAPI_API_SUCCESS;
 942 }
 943
 944 EXPORT_API int tel_deflect_call(TapiHandle *handle, unsigned int CallHandle, const TelCallDeflectDstInfo_t *pInfo, tapi_response_cb callback, void *user_data )
 945 {
 946         struct tapi_resp_data *evt_cb_data = 0;
 947         GVariant *param = 0;
 948
 949         dbg("Func Entrance ");
 950
 951         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 952         TAPI_RET_ERR_NUM_IF_FAIL(pInfo, TAPI_API_INVALID_PTR);
 953
 954         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 955
 956         param = g_variant_new("(is)", CallHandle, pInfo->number);
 957
 958         g_dbus_connection_call(handle->dbus_connection,
 959                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 960                         "Deflect", param, 0,
 961                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 962                         on_response_call_deflect, evt_cb_data );
 963
 964         return TAPI_API_SUCCESS;
 965 }
 966
 967 EXPORT_API int tel_get_call_status(TapiHandle *handle, int call_id, TelCallStatus_t *out )
 968 {
 969         GVariant *gv = 0;
 970         GVariant *param = 0;
 971
 972         GError *gerr = 0;
 973
 974         gchar *call_number;
 975         gint call_type = 0;
 976         gboolean call_direction = FALSE;
 977         gint call_state = 0;
 978         gboolean call_multiparty_state = FALSE;
 979
 980         dbg("Func Entrance ");
 981
 982         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 983         TAPI_RET_ERR_NUM_IF_FAIL(out, TAPI_API_INVALID_PTR);
 984
 985         param = g_variant_new("(i)", call_id);
 986
 987         gv = g_dbus_connection_call_sync(handle->dbus_connection,
 988                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 989                         "GetStatus", param, 0, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca, &gerr);
 990
 991         if ( gv ) {
 992                 g_variant_get(gv, "(isibib)", &call_id, &call_number, &call_type, &call_direction, &call_state, &call_multiparty_state);
 993
 994                 out->CallHandle = (int)call_id;
 995                 out->bMoCall = (int)call_direction;
 996                 strncpy( out->pNumber, call_number, TAPI_CALL_DIALDIGIT_LEN_MAX );
 997
 998                 dbg("[ check ] call_number : %s", call_number);
 999                 dbg("[ check ] out->pNumber : %s", out->pNumber);
1000
1001                 out->CallType = (TelCallType_t)call_type;
1002                 out->CallState = (TelCallStates_t)call_state;
1003                 out->bConferenceState = (int)call_multiparty_state;
1004
1005                 g_free( call_number );
1006
1007         } else {
1008                 dbg("[ error ] fail to get call status : (0x%x)", call_id);
1009                 g_error_free(gerr);
1010                 return TAPI_API_OPERATION_FAILED;
1011         }
1012
1013         return TAPI_API_SUCCESS;
1014 }
1015
1016 EXPORT_API int tel_get_call_status_all( TapiHandle *handle, TelCallStatusCallback cb, void *user_data )
1017 {
1018         GVariant *gv = 0;
1019         GVariantIter *iter = 0, *iter_row = 0;
1020         GError *gerr = 0;
1021
1022         dbg("Func Entrance ");
1023
1024         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1025         TAPI_RET_ERR_NUM_IF_FAIL(cb, TAPI_API_INVALID_PTR);
1026
1027         gv = g_dbus_connection_call_sync(handle->dbus_connection,
1028                                                                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
1029                                                                         "GetStatusAll", 0, 0, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca, &gerr);
1030
1031         if ( gv ) {
1032
1033                 TelCallStatus_t data;
1034                 gchar *key = 0;
1035                 GVariant *value = 0;
1036
1037                 g_variant_get(gv, "(aa{sv})", &iter);
1038
1039                 while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
1040
1041                         while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
1042
1043                                 if (!g_strcmp0(key, "call_id")) {
1044                                         data.CallHandle = g_variant_get_int32(value);
1045                                 }
1046                                 if (!g_strcmp0(key, "call_number")) {
1047                                         strncpy(data.pNumber, g_variant_get_string(value, 0), TAPI_CALL_DIALDIGIT_LEN_MAX);
1048                                 }
1049                                 if (!g_strcmp0(key, "call_type")) {
1050                                         data.CallType = (int)g_variant_get_int32(value);
1051                                 }
1052                                 if (!g_strcmp0(key, "call_direction")) {
1053                                         data.bMoCall = (int)g_variant_get_boolean(value);
1054                                 }
1055                                 if (!g_strcmp0(key, "call_state")) {
1056                                         data.CallState = (int)g_variant_get_int32(value);
1057                                 }
1058                                 if (!g_strcmp0(key, "call_multiparty_state")) {
1059                                         data.bConferenceState = (int)g_variant_get_boolean(value);
1060                                 }
1061
1062                         }
1063
1064                         g_variant_iter_free(iter_row);
1065
1066                         cb( &data, user_data );
1067                 }
1068                 g_variant_iter_free(iter);
1069         } else {
1070
1071                 dbg("[ error ] fail to get call status");
1072                 return TAPI_API_OPERATION_FAILED;
1073
1074         }
1075
1076         return TAPI_API_SUCCESS;
1077 }
1078
1079 EXPORT_API int tel_get_call_act_line(TapiHandle *handle, tapi_response_cb callback, void *user_data )
1080 {
1081         return TAPI_API_SUCCESS;
1082 }
1083
1084 EXPORT_API int tel_set_call_act_line(TapiHandle *handle, TelCallActiveLine_t active_line, tapi_response_cb callback, void *user_data )
1085 {
1086         return TAPI_API_SUCCESS;
1087 }
1088
1089 /*================================================================================================*/
1090
1091 EXPORT_API int tel_get_call_duration(TapiHandle *handle, unsigned int CallHandle, unsigned int *pDurationInSecs)
1092 {
1093         return TAPI_API_SUCCESS;
1094 }
1095
1096 EXPORT_API int tel_get_call_conf_list(TapiHandle *handle, unsigned int CallHandle, unsigned int *pCallList, int *pNoOfCalls)
1097 {
1098         return TAPI_API_SUCCESS;
1099 }
1100
1101 EXPORT_API int tel_get_call_privacy_mode(TapiHandle *handle, TelCallPrivacyType_t PrivacyType, tapi_response_cb callback, void *user_data )
1102 {
1103         return TAPI_API_SUCCESS;
1104 }
1105
1106 EXPORT_API int tel_set_call_privacy_mode(TapiHandle *handle, TelCallVoicePrivacyInfo_t PrivacyInfo, tapi_response_cb callback, void *user_data )
1107 {
1108         return TAPI_API_SUCCESS;
1109 }
1110
1111 EXPORT_API int tel_exe_call_flash_info(TapiHandle *handle, const char *pDialNumber, tapi_response_cb callback, void *user_data )
1112 {
1113         return TAPI_API_SUCCESS;
1114 }
1115
1116 EXPORT_API int tel_exit_call_emergency_mode(TapiHandle *handle, tapi_response_cb callback, void *user_data )
1117 {
1118         return TAPI_API_SUCCESS;
1119 }
1120
1121 EXPORT_API int tel_get_call_time(TapiHandle *handle, unsigned short req_mask, tapi_response_cb callback, void *user_data )
1122 {
1123         return TAPI_API_SUCCESS;
1124 }
1125
1126 EXPORT_API int tel_get_call_volume_info(TapiHandle *handle, TelSoundDevice_t device, TelSoundType_t type, tapi_response_cb callback, void *user_data )
1127 {
1128         struct tapi_resp_data *evt_cb_data = 0;
1129         GVariant *param = 0;
1130
1131         dbg("Func Entrance ");
1132
1133         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1134
1135         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1136
1137         param = g_variant_new("(ii)", device, type);
1138
1139         g_dbus_connection_call(handle->dbus_connection,
1140                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
1141                         "GetSoundVolumeLevel", param, 0,
1142                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1143                         on_response_get_call_volume_info, evt_cb_data );
1144
1145         return TAPI_API_SUCCESS;
1146 }
1147
1148 EXPORT_API int tel_set_call_volume_info(TapiHandle *handle, TelCallVolumeInfo_t *info, tapi_response_cb callback, void *user_data )
1149 {
1150         struct tapi_resp_data *evt_cb_data = 0;
1151         GVariant *param = 0;
1152
1153         dbg("Func Entrance ");
1154
1155         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1156         TAPI_RET_ERR_NUM_IF_FAIL(info, TAPI_API_INVALID_PTR);
1157
1158         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1159
1160         param = g_variant_new("(iii)", info->device, info->type, info->volume);
1161
1162         g_dbus_connection_call(handle->dbus_connection,
1163                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
1164                         "SetSoundVolumeLevel", param, 0,
1165                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1166                         on_response_set_call_volume_info, evt_cb_data );
1167
1168         return TAPI_API_SUCCESS;
1169 }
1170
1171 EXPORT_API int tel_set_call_sound_path(TapiHandle *handle, TelCallSoundPathInfo_t *info, tapi_response_cb callback, void *user_data )
1172 {
1173         struct tapi_resp_data *evt_cb_data = 0;
1174         GVariant *param = 0;
1175
1176         dbg("Func Entrance ");
1177
1178         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1179         TAPI_RET_ERR_NUM_IF_FAIL(info, TAPI_API_INVALID_PTR);
1180
1181         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1182
1183         param = g_variant_new("(ib)", info->path, info->ex_volume);
1184
1185         g_dbus_connection_call(handle->dbus_connection,
1186                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
1187                         "SetSoundPath", param, 0,
1188                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1189                         on_response_set_call_sound_path, evt_cb_data );
1190
1191         return TAPI_API_SUCCESS;
1192 }
1193
1194 EXPORT_API int tel_set_call_mute_status(TapiHandle *handle, TelSoundMuteStatus_t mute, TelSoundMutePath_t path, tapi_response_cb callback, void *user_data )
1195 {
1196         struct tapi_resp_data *evt_cb_data = 0;
1197         GVariant *param = 0;
1198
1199         dbg("Func Entrance ");
1200
1201         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1202
1203         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1204
1205         param = g_variant_new("(ii)", mute, path);
1206
1207         g_dbus_connection_call(handle->dbus_connection,
1208                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
1209                         "SetSoundMuteStatus", param, 0,
1210                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1211                         on_response_set_call_mute_status, evt_cb_data );
1212
1213         return TAPI_API_SUCCESS;
1214 }
1215
1216 EXPORT_API int tel_get_call_mute_status(TapiHandle *handle, tapi_response_cb callback, void *user_data )
1217 {
1218         struct tapi_resp_data *evt_cb_data = 0;
1219
1220         dbg("Func Entrance ");
1221
1222         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1223         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
1224
1225         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1226
1227         g_dbus_connection_call(handle->dbus_connection,
1228                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
1229                         "GetSoundMuteStatus", 0, 0,
1230                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1231                         on_response_get_call_mute_status, evt_cb_data );
1232
1233         return TAPI_API_SUCCESS;
1234 }
1235
1236 EXPORT_API  int tel_set_call_sound_recording(TapiHandle *handle, TelSoundRecording_t *on, tapi_response_cb callback, void *user_data)
1237 {
1238         struct tapi_resp_data *evt_cb_data = 0;
1239         GVariant *param = 0;
1240
1241         dbg("Func Entrance ");
1242
1243         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1244
1245         param = g_variant_new("(i)", *on);
1246
1247         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1248
1249         g_dbus_connection_call(handle->dbus_connection,
1250                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
1251                         "SetSoundRecording", param, 0,
1252                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1253                         on_response_set_call_sound_recording, evt_cb_data );
1254
1255         return TAPI_API_SUCCESS;
1256 }
1257
1258 EXPORT_API  int tel_set_call_sound_equalization(TapiHandle *handle, TelCallSoundEqualization_t *eq, tapi_response_cb callback, void *user_data)
1259 {
1260         struct tapi_resp_data *evt_cb_data = 0;
1261         GVariant *param = 0;
1262         char *eq_param = 0;
1263
1264         dbg("Func Entrance ");
1265
1266         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1267         TAPI_RET_ERR_NUM_IF_FAIL(eq, TAPI_API_INVALID_PTR);
1268
1269         eq_param = (char*)eq->parameter;
1270
1271         param = g_variant_new("(iis)", eq->mode, eq->direction, eq_param);
1272
1273         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1274
1275         g_dbus_connection_call(handle->dbus_connection,
1276                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
1277                         "SetSoundEqualization", param, 0,
1278                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1279                         on_response_set_call_sound_equalization, evt_cb_data );
1280
1281         return TAPI_API_SUCCESS;
1282 }
1283
1284 EXPORT_API  int tel_set_call_sound_noise_reduction(TapiHandle *handle, TelSoundNoiseReduction_t noise, tapi_response_cb callback, void *user_data)
1285 {
1286         struct tapi_resp_data *evt_cb_data = 0;
1287         GVariant *param = 0;
1288
1289         dbg("Func Entrance ");
1290
1291         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1292
1293         param = g_variant_new("(i)", noise);
1294
1295         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1296
1297         g_dbus_connection_call(handle->dbus_connection,
1298                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
1299                         "SetSoundNoiseReduction", param, 0,
1300                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1301                         on_response_set_call_sound_noise_reduction, evt_cb_data );
1302
1303         return TAPI_API_SUCCESS;
1304 }
1305
1306 EXPORT_API int tel_set_call_sound_clock_status(TapiHandle *handle, gboolean status, tapi_response_cb callback, void *user_data )
1307 {
1308         struct tapi_resp_data *evt_cb_data = 0;
1309         GVariant *param = 0;
1310
1311         dbg("Func Entrance");
1312
1313         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1314
1315         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1316
1317         param = g_variant_new("(b)", status);
1318
1319         g_dbus_connection_call(handle->dbus_connection,
1320                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
1321                         "SetSoundClockStatus", param, 0,
1322                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1323                         on_response_set_call_sound_clock_status, evt_cb_data );
1324
1325         return TAPI_API_SUCCESS;
1326 }
1327
1328 /*      EOF  */