mobile/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         dbg("Func Entrance");
  43
  44         conn = G_DBUS_CONNECTION (source_object);
  45         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
  46
  47         g_variant_get (dbus_result, "(i)", &result);
  48         if (result != TAPI_CAUSE_SUCCESS)
  49                 dbg("Modem dialing failed");
  50
  51         if (evt_cb_data->cb_fn) {
  52                 evt_cb_data->cb_fn(evt_cb_data->handle, result, 0, evt_cb_data->user_data);
  53         }
  54         dbg("Exit");
  55 }
  56
  57 static void on_response_call_answer(GObject *source_object, GAsyncResult *res, gpointer user_data)
  58 {
  59         GError *error = 0;
  60         GDBusConnection *conn = 0;
  61         struct tapi_resp_data *evt_cb_data = user_data;
  62         int result = -1;
  63         TelCallAnswerCnf_t data;
  64
  65         GVariant *dbus_result;
  66
  67         conn = G_DBUS_CONNECTION (source_object);
  68         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
  69
  70         g_variant_get (dbus_result, "(ii)", &result, &data.id);
  71
  72         if (evt_cb_data->cb_fn) {
  73                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
  74         }
  75 }
  76
  77 static void on_response_call_end(GObject *source_object, GAsyncResult *res, gpointer user_data)
  78 {
  79         GError *error = 0;
  80         GDBusConnection *conn = 0;
  81         struct tapi_resp_data *evt_cb_data = user_data;
  82         int result = -1;
  83         TelCallEndCnf_t data;
  84
  85         GVariant *dbus_result;
  86
  87         conn = G_DBUS_CONNECTION (source_object);
  88         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
  89
  90         g_variant_get (dbus_result, "(iii)", &result, &data.id, &data.type);
  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 }
  96
  97 static void on_response_call_hold(GObject *source_object, GAsyncResult *res, gpointer user_data)
  98 {
  99         GError *error = 0;
 100         GDBusConnection *conn = 0;
 101         struct tapi_resp_data *evt_cb_data = user_data;
 102         int result = -1;
 103         TelCallHoldCnf_t data;
 104
 105         GVariant *dbus_result;
 106
 107         conn = G_DBUS_CONNECTION (source_object);
 108         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 109
 110         g_variant_get (dbus_result, "(ii)", &result, &data.id);
 111
 112         if (evt_cb_data->cb_fn) {
 113                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
 114         }
 115
 116 }
 117
 118 static void on_response_call_active(GObject *source_object, GAsyncResult *res, gpointer user_data)
 119 {
 120         GError *error = 0;
 121         GDBusConnection *conn = 0;
 122         struct tapi_resp_data *evt_cb_data = user_data;
 123         int result = -1;
 124         TelCallActiveCnf_t data;
 125
 126         GVariant *dbus_result;
 127
 128         conn = G_DBUS_CONNECTION (source_object);
 129         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 130
 131         g_variant_get (dbus_result, "(ii)", &result, &data.id);
 132
 133         if (evt_cb_data->cb_fn) {
 134                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
 135         }
 136
 137
 138 }
 139
 140 static void on_response_call_swap(GObject *source_object, GAsyncResult *res, gpointer user_data)
 141 {
 142         GError *error = 0;
 143         GDBusConnection *conn = 0;
 144         struct tapi_resp_data *evt_cb_data = user_data;
 145         int result = -1;
 146         TelCallSwapCnf_t data;
 147
 148         GVariant *dbus_result;
 149
 150         conn = G_DBUS_CONNECTION (source_object);
 151         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 152
 153         g_variant_get (dbus_result, "(ii)", &result, &data.id);
 154
 155         if (evt_cb_data->cb_fn) {
 156                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
 157         }
 158 }
 159
 160 static void on_response_call_join(GObject *source_object, GAsyncResult *res, gpointer user_data)
 161 {
 162         GError *error = 0;
 163         GDBusConnection *conn = 0;
 164         struct tapi_resp_data *evt_cb_data = user_data;
 165         int result = -1;
 166         TelCallJoinCnf_t data;
 167
 168         GVariant *dbus_result;
 169
 170         conn = G_DBUS_CONNECTION (source_object);
 171         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 172
 173         g_variant_get (dbus_result, "(ii)", &result, &data.id);
 174
 175         if (evt_cb_data->cb_fn) {
 176                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
 177         }
 178 }
 179
 180 static void on_response_call_split(GObject *source_object, GAsyncResult *res, gpointer user_data)
 181 {
 182         GError *error = 0;
 183         GDBusConnection *conn = 0;
 184         struct tapi_resp_data *evt_cb_data = user_data;
 185         int result = -1;
 186         TelCallSplitCnf_t data;
 187
 188         GVariant *dbus_result;
 189
 190         conn = G_DBUS_CONNECTION (source_object);
 191         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 192
 193         g_variant_get (dbus_result, "(ii)", &result, &data.id);
 194
 195         if (evt_cb_data->cb_fn) {
 196                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
 197         }
 198 }
 199
 200 static void on_response_call_transfer(GObject *source_object, GAsyncResult *res, gpointer user_data)
 201 {
 202         GError *error = 0;
 203         GDBusConnection *conn = 0;
 204         struct tapi_resp_data *evt_cb_data = user_data;
 205         int result = -1;
 206         TelCallTransferCnf_t data;
 207
 208         GVariant *dbus_result;
 209
 210         conn = G_DBUS_CONNECTION (source_object);
 211         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 212
 213         g_variant_get (dbus_result, "(ii)", &result, &data.id);
 214
 215         if (evt_cb_data->cb_fn) {
 216                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
 217         }
 218 }
 219
 220 static void on_response_call_dtmf(GObject *source_object, GAsyncResult *res, gpointer user_data)
 221 {
 222         GError *error = 0;
 223         GDBusConnection *conn = 0;
 224         struct tapi_resp_data *evt_cb_data = user_data;
 225         int result = -1;
 226
 227         GVariant *dbus_result;
 228
 229         conn = G_DBUS_CONNECTION (source_object);
 230         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 231
 232         g_variant_get (dbus_result, "(i)", &result);
 233
 234         if (evt_cb_data->cb_fn) {
 235                 evt_cb_data->cb_fn(evt_cb_data->handle, result, 0, evt_cb_data->user_data);
 236         }
 237 }
 238
 239 static void on_response_call_deflect(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
 251         g_variant_get (dbus_result, "(i)", &result);
 252
 253         if (evt_cb_data->cb_fn) {
 254                 evt_cb_data->cb_fn(evt_cb_data->handle, result, 0, evt_cb_data->user_data);
 255         }
 256 }
 257
 258 static void on_response_get_call_volume_info(GObject *source_object, GAsyncResult *res, gpointer user_data)
 259 {
 260         GError *error = 0;
 261         GDBusConnection *conn = 0;
 262         struct tapi_resp_data *evt_cb_data = user_data;
 263         int result = -1, i = 0;
 264         TelCallGetVolumeInfoResp_t resp;
 265
 266         GVariant *dbus_result = 0, *value = 0;
 267         GVariantIter *iter = 0;
 268         GVariantIter *iter_row = 0;
 269         const gchar *key = 0;
 270
 271
 272         memset(&resp, '\0', sizeof(TelCallGetVolumeInfoResp_t));
 273
 274         conn = G_DBUS_CONNECTION (source_object);
 275         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 276
 277         g_variant_get (dbus_result, "(aa{sv}i)", &iter, &result);
 278
 279         resp.record_num = g_variant_iter_n_children(iter);
 280
 281         while ( g_variant_iter_next(iter, "a{sv}", &iter_row ) ) {
 282                 while ( g_variant_iter_loop( iter_row, "{sv}", &key, &value ) ) {
 283
 284                         if ( !g_strcmp0(key, "type") ) {
 285                                 int type = g_variant_get_int32(value);
 286
 287                                 resp.record[i].device = (type & 0xf0);
 288                                 resp.record[i].type = (type & 0x0f);
 289                         }
 290
 291                         if ( !g_strcmp0(key, "level") ) {
 292                                 resp.record[i].volume = g_variant_get_int32(value);
 293                         }
 294                 }
 295                 i++;
 296                 g_variant_iter_free(iter_row);
 297         }
 298         g_variant_iter_free(iter);
 299
 300         if (evt_cb_data->cb_fn) {
 301                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &resp, evt_cb_data->user_data);
 302         }
 303 }
 304
 305 static void on_response_set_call_volume_info(GObject *source_object, GAsyncResult *res, gpointer user_data)
 306 {
 307         GError *error = 0;
 308         GDBusConnection *conn = 0;
 309         struct tapi_resp_data *evt_cb_data = user_data;
 310         int result = -1;
 311
 312         GVariant *dbus_result;
 313
 314         conn = G_DBUS_CONNECTION (source_object);
 315         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 316
 317         g_variant_get (dbus_result, "(i)", &result);
 318
 319         if (evt_cb_data->cb_fn) {
 320                 evt_cb_data->cb_fn(evt_cb_data->handle, result, 0, evt_cb_data->user_data);
 321         }
 322 }
 323
 324 static void on_response_set_call_sound_path(GObject *source_object, GAsyncResult *res, gpointer user_data)
 325 {
 326         GError *error = 0;
 327         GDBusConnection *conn = 0;
 328         struct tapi_resp_data *evt_cb_data = user_data;
 329         int result = -1;
 330
 331         GVariant *dbus_result;
 332
 333         conn = G_DBUS_CONNECTION (source_object);
 334         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 335
 336         g_variant_get (dbus_result, "(i)", &result);
 337
 338         if (evt_cb_data->cb_fn) {
 339                 evt_cb_data->cb_fn(evt_cb_data->handle, result, 0, evt_cb_data->user_data);
 340         }
 341 }
 342
 343 static void on_response_set_call_mute_status(GObject *source_object, GAsyncResult *res, gpointer user_data)
 344 {
 345         GError *error = 0;
 346         GDBusConnection *conn = 0;
 347         struct tapi_resp_data *evt_cb_data = user_data;
 348         int result = -1;
 349
 350         GVariant *dbus_result;
 351
 352         conn = G_DBUS_CONNECTION (source_object);
 353         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 354
 355         g_variant_get (dbus_result, "(i)", &result);
 356
 357         if (evt_cb_data->cb_fn) {
 358                 evt_cb_data->cb_fn(evt_cb_data->handle, result, 0, evt_cb_data->user_data);
 359         }
 360 }
 361
 362 static void on_response_get_call_mute_status(GObject *source_object, GAsyncResult *res, gpointer user_data)
 363 {
 364         GError *error = 0;
 365         GDBusConnection *conn = 0;
 366         struct tapi_resp_data *evt_cb_data = user_data;
 367         int result = -1, status = 0;
 368         TelCallGetMuteStatusResp_t resp;
 369
 370         GVariant *dbus_result;
 371
 372         conn = G_DBUS_CONNECTION (source_object);
 373         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 374
 375         g_variant_get (dbus_result, "(ii)", &result, &resp.status);
 376
 377         if (evt_cb_data->cb_fn) {
 378                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &status, evt_cb_data->user_data);
 379         }
 380 }
 381
 382 static void on_response_set_call_sound_recording(GObject *source_object, GAsyncResult *res, gpointer user_data)
 383 {
 384         GError *error = 0;
 385         GDBusConnection *conn = 0;
 386         struct tapi_resp_data *evt_cb_data = user_data;
 387         int result = -1;
 388
 389         GVariant *dbus_result;
 390
 391         conn = G_DBUS_CONNECTION (source_object);
 392         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 393
 394         g_variant_get (dbus_result, "(i)", &result);
 395
 396         if (evt_cb_data->cb_fn) {
 397                 evt_cb_data->cb_fn(evt_cb_data->handle, result, 0, evt_cb_data->user_data);
 398         }
 399 }
 400
 401 static void on_response_set_call_sound_equalization(GObject *source_object, GAsyncResult *res, gpointer user_data)
 402 {
 403         GError *error = 0;
 404         GDBusConnection *conn = 0;
 405         struct tapi_resp_data *evt_cb_data = user_data;
 406         int result = -1;
 407
 408         GVariant *dbus_result;
 409
 410         conn = G_DBUS_CONNECTION (source_object);
 411         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 412
 413         g_variant_get (dbus_result, "(i)", &result);
 414
 415         if (evt_cb_data->cb_fn) {
 416                 evt_cb_data->cb_fn(evt_cb_data->handle, result, 0, evt_cb_data->user_data);
 417         }
 418 }
 419
 420 static void on_response_set_call_sound_noise_reduction(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
 432         g_variant_get (dbus_result, "(i)", &result);
 433
 434         if (evt_cb_data->cb_fn) {
 435                 evt_cb_data->cb_fn(evt_cb_data->handle, result, 0, evt_cb_data->user_data);
 436         }
 437 }
 438
 439 static void on_response_set_call_sound_clock_status(GObject *source_object, GAsyncResult *res, gpointer user_data)
 440 {
 441         GError *error = 0;
 442         GDBusConnection *conn = 0;
 443         struct tapi_resp_data *evt_cb_data = user_data;
 444         int result = -1;
 445
 446         GVariant *dbus_result;
 447
 448         conn = G_DBUS_CONNECTION (source_object);
 449         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 450
 451         g_variant_get (dbus_result, "(i)", &result);
 452
 453         if (evt_cb_data->cb_fn) {
 454                 evt_cb_data->cb_fn(evt_cb_data->handle, result, 0, evt_cb_data->user_data);
 455         }
 456 }
 457
 458
 459 EXPORT_API int tel_dial_call(TapiHandle *handle, const TelCallDial_t *pParams, tapi_response_cb callback, void *user_data)
 460 {
 461         struct tapi_resp_data *evt_cb_data = 0;
 462         GVariant *param = 0;
 463
 464         dbg("Func Entrance");
 465         if (!pParams)
 466                 return TAPI_API_INVALID_INPUT;
 467
 468         dbg("Destination Number : %s", pParams->szNumber);
 469
 470         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 471
 472         param = g_variant_new("(is)", pParams->CallType, pParams->szNumber);
 473
 474         g_dbus_connection_call(handle->dbus_connection,
 475                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 476                         "Dial", param, 0,
 477                         G_DBUS_CALL_FLAGS_NONE, -1, 0,
 478                         on_response_call_dial, evt_cb_data );
 479         dbg("Exit");
 480         return TAPI_API_SUCCESS;
 481 }
 482
 483
 484 EXPORT_API int tel_answer_call(TapiHandle *handle, unsigned int CallHandle, TelCallAnswerType_t AnsType, tapi_response_cb callback, void *user_data )
 485 {
 486         struct tapi_resp_data *evt_cb_data = 0;
 487         GVariant *param = 0;
 488
 489         dbg("Func Entrance ");
 490
 491         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 492
 493         param = g_variant_new("(ii)", CallHandle, AnsType);
 494
 495         g_dbus_connection_call(handle->dbus_connection,
 496                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 497                         "Answer", param, 0,
 498                         G_DBUS_CALL_FLAGS_NONE, -1, 0,
 499                         on_response_call_answer, evt_cb_data );
 500
 501         return TAPI_API_SUCCESS;
 502 }
 503
 504 EXPORT_API int tel_end_call(TapiHandle *handle, unsigned int CallHandle, TelCallEndType_t EndType, tapi_response_cb callback, void *user_data)
 505 {
 506         struct tapi_resp_data *evt_cb_data = 0;
 507         GVariant *param = 0;
 508
 509         dbg("Func Entrance ");
 510
 511         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 512
 513         param = g_variant_new("(ii)", CallHandle, EndType);
 514
 515         g_dbus_connection_call(handle->dbus_connection,
 516                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 517                         "End", param, 0,
 518                         G_DBUS_CALL_FLAGS_NONE, -1, 0,
 519                         on_response_call_end, evt_cb_data );
 520
 521         return TAPI_API_SUCCESS;
 522 }
 523
 524 EXPORT_API int tel_hold_call(TapiHandle *handle, unsigned int CallHandle, tapi_response_cb callback, void *user_data )
 525 {
 526         struct tapi_resp_data *evt_cb_data = 0;
 527         GVariant *param = 0;
 528
 529         dbg("Func Entrance ");
 530
 531         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 532
 533         param = g_variant_new("(i)", CallHandle);
 534
 535         g_dbus_connection_call(handle->dbus_connection,
 536                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 537                         "Hold", param, 0,
 538                         G_DBUS_CALL_FLAGS_NONE, -1, 0,
 539                         on_response_call_hold, evt_cb_data );
 540
 541         return TAPI_API_SUCCESS;
 542 }
 543
 544 EXPORT_API int tel_active_call(TapiHandle *handle, unsigned int CallHandle, tapi_response_cb callback, void *user_data )
 545 {
 546         struct tapi_resp_data *evt_cb_data = 0;
 547         GVariant *param = 0;
 548
 549         dbg("Func Entrance ");
 550
 551         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 552
 553         param = g_variant_new("(i)", CallHandle);
 554
 555         g_dbus_connection_call(handle->dbus_connection,
 556                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 557                         "Active", param, 0,
 558                         G_DBUS_CALL_FLAGS_NONE, -1, 0,
 559                         on_response_call_active, evt_cb_data );
 560
 561         return TAPI_API_SUCCESS;
 562 }
 563
 564 EXPORT_API int tel_swap_call(TapiHandle *handle, unsigned int CallHandle1, unsigned int CallHandle2, tapi_response_cb callback, void *user_data )
 565 {
 566         struct tapi_resp_data *evt_cb_data = 0;
 567         GVariant *param = 0;
 568
 569         dbg("Func Entrance ");
 570
 571         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 572
 573         param = g_variant_new("(i)", CallHandle1, CallHandle2);
 574
 575         g_dbus_connection_call(handle->dbus_connection,
 576                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 577                         "Swap", param, 0,
 578                         G_DBUS_CALL_FLAGS_NONE, -1, 0,
 579                         on_response_call_swap, evt_cb_data );
 580
 581         return TAPI_API_SUCCESS;
 582 }
 583
 584 EXPORT_API int tel_join_call(TapiHandle *handle, unsigned int CallHandle1, unsigned int CallHandle2, tapi_response_cb callback, void *user_data )
 585 {
 586         struct tapi_resp_data *evt_cb_data = 0;
 587         GVariant *param = 0;
 588
 589         dbg("Func Entrance ");
 590
 591         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 592
 593         param = g_variant_new("(i)", CallHandle1, CallHandle2);
 594
 595         g_dbus_connection_call(handle->dbus_connection,
 596                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 597                         "Join", param, 0,
 598                         G_DBUS_CALL_FLAGS_NONE, -1, 0,
 599                         on_response_call_join, evt_cb_data );
 600
 601         return TAPI_API_SUCCESS;
 602 }
 603
 604 EXPORT_API int tel_split_call(TapiHandle *handle, unsigned int CallHandle, tapi_response_cb callback, void *user_data )
 605 {
 606         struct tapi_resp_data *evt_cb_data = 0;
 607         GVariant *param = 0;
 608
 609         dbg("Func Entrance ");
 610
 611         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 612
 613         param = g_variant_new("(i)", CallHandle);
 614
 615         g_dbus_connection_call(handle->dbus_connection,
 616                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 617                         "Split", param, 0,
 618                         G_DBUS_CALL_FLAGS_NONE, -1, 0,
 619                         on_response_call_split, evt_cb_data );
 620
 621         return TAPI_API_SUCCESS;
 622 }
 623
 624 EXPORT_API int tel_transfer_call(TapiHandle *handle, unsigned int CallHandle, tapi_response_cb callback, void *user_data )
 625 {
 626         struct tapi_resp_data *evt_cb_data = 0;
 627         GVariant *param = 0;
 628
 629         dbg("Func Entrance ");
 630
 631         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 632
 633         param = g_variant_new("(i)", CallHandle);
 634
 635         g_dbus_connection_call(handle->dbus_connection,
 636                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 637                         "Transfer", param, 0,
 638                         G_DBUS_CALL_FLAGS_NONE, -1, 0,
 639                         on_response_call_transfer, evt_cb_data );
 640
 641         return TAPI_API_SUCCESS;
 642 }
 643
 644 EXPORT_API int tel_activate_call_ccbs(TapiHandle *handle, unsigned int CallHandle, tapi_response_cb callback, void *user_data )
 645 {
 646         return TAPI_API_SUCCESS;
 647 }
 648
 649 EXPORT_API int tel_call_dtmf(TapiHandle *handle, const char *pDtmfString, tapi_response_cb callback, void *user_data )
 650 {
 651         struct tapi_resp_data *evt_cb_data = 0;
 652         GVariant *param = 0;
 653
 654         dbg("Func Entrance ");
 655
 656         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 657
 658         param = g_variant_new("(s)", pDtmfString);
 659
 660         g_dbus_connection_call(handle->dbus_connection,
 661                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 662                         "Dtmf", param, 0,
 663                         G_DBUS_CALL_FLAGS_NONE, -1, 0,
 664                         on_response_call_dtmf, evt_cb_data );
 665
 666         return TAPI_API_SUCCESS;
 667 }
 668
 669 EXPORT_API int tel_deflect_call(TapiHandle *handle, unsigned int CallHandle, const TelCallDeflectDstInfo_t *pInfo, tapi_response_cb callback, void *user_data )
 670 {
 671         struct tapi_resp_data *evt_cb_data = 0;
 672         GVariant *param = 0;
 673
 674         dbg("Func Entrance ");
 675
 676         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 677
 678         param = g_variant_new("(is)", CallHandle, pInfo->number);
 679
 680         g_dbus_connection_call(handle->dbus_connection,
 681                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 682                         "Deflect", param, 0,
 683                         G_DBUS_CALL_FLAGS_NONE, -1, 0,
 684                         on_response_call_deflect, evt_cb_data );
 685
 686         return TAPI_API_SUCCESS;
 687 }
 688
 689 EXPORT_API int tel_get_call_status(TapiHandle *handle, int call_id, TelCallStatus_t *out )
 690 {
 691         GVariant *gv = 0;
 692         GVariant *param = 0;
 693
 694         GError *gerr = 0;
 695
 696         gchar *call_number;
 697         gint call_type = 0;
 698         gboolean call_direction = FALSE;
 699         gint call_state = 0;
 700         gboolean call_multiparty_state = FALSE;
 701
 702         if ( !out ) {
 703                 dbg("[ error ] out : 0 ");
 704                 return TAPI_API_INVALID_INPUT;
 705         }
 706
 707         param = g_variant_new("(i)", call_id);
 708
 709         gv = g_dbus_connection_call_sync(handle->dbus_connection,
 710                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 711                         "GetStatus", param, 0, G_DBUS_CALL_FLAGS_NONE, -1, 0,   &gerr);
 712
 713         if ( gv ) {
 714                 g_variant_get(gv, "(isibib)", &call_id, &call_number, &call_type, &call_direction, &call_state, &call_multiparty_state);
 715
 716                 out->CallHandle = (int)call_id;
 717                 out->bMoCall = (int)call_direction;
 718                 strncpy( out->pNumber, call_number, TAPI_CALL_DIALDIGIT_LEN_MAX );
 719
 720                 dbg("[ check ] call_number : %s", call_number);
 721                 dbg("[ check ] out->pNumber : %s", out->pNumber);
 722
 723                 out->CallType = (TelCallType_t)call_type;
 724                 out->CallState = (TelCallStates_t)call_state;
 725                 out->bConferenceState = (int)call_multiparty_state;
 726
 727                 g_free( call_number );
 728
 729         } else {
 730
 731                 dbg("[ error ] fail to get call status : (0x%x)", call_id);
 732                 return TAPI_API_OPERATION_FAILED;
 733         }
 734
 735         return TAPI_API_SUCCESS;
 736 }
 737
 738 EXPORT_API int tel_get_call_status_all( TapiHandle *handle, TelCallStatusCallback cb, void *user_data )
 739 {
 740         GVariant *gv = 0;
 741         GVariantIter *iter = 0, *iter_row = 0;
 742         GError *gerr = 0;
 743
 744         if ( !cb ) {
 745                 dbg("[ error ] out : 0 ");
 746                 return TAPI_API_INVALID_INPUT;
 747         }
 748
 749         gv = g_dbus_connection_call_sync(handle->dbus_connection,
 750                                                                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 751                                                                         "GetStatusAll", 0, 0, G_DBUS_CALL_FLAGS_NONE, -1, 0, &gerr);
 752
 753         if ( gv ) {
 754
 755                 TelCallStatus_t data;
 756                 gchar *key = 0;
 757                 GVariant *value = 0;
 758
 759                 g_variant_get(gv, "(aa{sv})", &iter);
 760
 761                 while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
 762
 763                         while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
 764
 765                                 if (!g_strcmp0(key, "call_id")) {
 766                                         data.CallHandle = g_variant_get_int32(value);
 767                                 }
 768                                 if (!g_strcmp0(key, "call_number")) {
 769                                         strncpy(data.pNumber, g_variant_get_string(value, 0), TAPI_CALL_DIALDIGIT_LEN_MAX);
 770                                 }
 771                                 if (!g_strcmp0(key, "call_type")) {
 772                                         data.CallType = (int)g_variant_get_int32(value);
 773                                 }
 774                                 if (!g_strcmp0(key, "call_direction")) {
 775                                         data.bMoCall = (int)g_variant_get_boolean(value);
 776                                 }
 777                                 if (!g_strcmp0(key, "call_state")) {
 778                                         data.CallState = (int)g_variant_get_int32(value);
 779                                 }
 780                                 if (!g_strcmp0(key, "call_multiparty_state")) {
 781                                         data.bConferenceState = (int)g_variant_get_boolean(value);
 782                                 }
 783
 784                         }
 785
 786                         g_variant_iter_free(iter_row);
 787
 788                         cb( &data, user_data );
 789                 }
 790                 g_variant_iter_free(iter);
 791         } else {
 792
 793                 dbg("[ error ] fail to get call status");
 794                 return TAPI_API_OPERATION_FAILED;
 795
 796         }
 797
 798         return TAPI_API_SUCCESS;
 799 }
 800
 801 EXPORT_API int tel_get_call_act_line(TapiHandle *handle, tapi_response_cb callback, void *user_data )
 802 {
 803         return TAPI_API_SUCCESS;
 804 }
 805
 806 EXPORT_API int tel_set_call_act_line(TapiHandle *handle, TelCallActiveLine_t active_line, tapi_response_cb callback, void *user_data )
 807 {
 808         return TAPI_API_SUCCESS;
 809 }
 810
 811 /*================================================================================================*/
 812
 813 EXPORT_API int tel_get_call_duration(TapiHandle *handle, unsigned int CallHandle, unsigned int *pDurationInSecs)
 814 {
 815         return TAPI_API_SUCCESS;
 816 }
 817
 818 EXPORT_API int tel_get_call_conf_list(TapiHandle *handle, unsigned int CallHandle, unsigned int *pCallList, int *pNoOfCalls)
 819 {
 820         return TAPI_API_SUCCESS;
 821 }
 822
 823 EXPORT_API int tel_get_call_privacy_mode(TapiHandle *handle, TelCallPrivacyType_t PrivacyType, tapi_response_cb callback, void *user_data )
 824 {
 825         return TAPI_API_SUCCESS;
 826 }
 827
 828 EXPORT_API int tel_set_call_privacy_mode(TapiHandle *handle, TelCallVoicePrivacyInfo_t PrivacyInfo, tapi_response_cb callback, void *user_data )
 829 {
 830         return TAPI_API_SUCCESS;
 831 }
 832
 833 EXPORT_API int tel_exe_call_flash_info(TapiHandle *handle, const char *pDialNumber, tapi_response_cb callback, void *user_data )
 834 {
 835         return TAPI_API_SUCCESS;
 836 }
 837
 838 EXPORT_API int tel_exit_call_emergency_mode(TapiHandle *handle, tapi_response_cb callback, void *user_data )
 839 {
 840         return TAPI_API_SUCCESS;
 841 }
 842
 843 EXPORT_API int tel_get_call_time(TapiHandle *handle, unsigned short req_mask, tapi_response_cb callback, void *user_data )
 844 {
 845         return TAPI_API_SUCCESS;
 846 }
 847
 848 EXPORT_API int tel_get_call_volume_info(TapiHandle *handle, TelSoundDevice_t device, TelSoundType_t type, tapi_response_cb callback, void *user_data )
 849 {
 850         struct tapi_resp_data *evt_cb_data = 0;
 851         GVariant *param = 0;
 852
 853         dbg("Func Entrance ");
 854
 855         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 856
 857         param = g_variant_new("(ii)", device, type);
 858
 859         g_dbus_connection_call(handle->dbus_connection,
 860                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 861                         "GetVolume", param, 0,
 862                         G_DBUS_CALL_FLAGS_NONE, -1, 0,
 863                         on_response_get_call_volume_info, evt_cb_data );
 864
 865         return TAPI_API_SUCCESS;
 866 }
 867
 868 EXPORT_API int tel_set_call_volume_info(TapiHandle *handle, TelCallVolumeInfo_t *info, tapi_response_cb callback, void *user_data )
 869 {
 870         struct tapi_resp_data *evt_cb_data = 0;
 871         GVariant *param = 0;
 872
 873         dbg("Func Entrance ");
 874
 875         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 876
 877         param = g_variant_new("(iii)", info->device, info->type, info->volume);
 878
 879         g_dbus_connection_call(handle->dbus_connection,
 880                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 881                         "SetVolume", param, 0,
 882                         G_DBUS_CALL_FLAGS_NONE, -1, 0,
 883                         on_response_set_call_volume_info, evt_cb_data );
 884
 885         return TAPI_API_SUCCESS;
 886 }
 887
 888 EXPORT_API int tel_set_call_sound_path(TapiHandle *handle, TelCallSoundPathInfo_t *info, tapi_response_cb callback, void *user_data )
 889 {
 890         struct tapi_resp_data *evt_cb_data = 0;
 891         GVariant *param = 0;
 892
 893         dbg("Func Entrance ");
 894
 895         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 896
 897         param = g_variant_new("(ib)", info->path, info->ex_volume);
 898
 899         g_dbus_connection_call(handle->dbus_connection,
 900                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 901                         "SetSoundPath", param, 0,
 902                         G_DBUS_CALL_FLAGS_NONE, -1, 0,
 903                         on_response_set_call_sound_path, evt_cb_data );
 904
 905         return TAPI_API_SUCCESS;
 906 }
 907
 908 EXPORT_API int tel_set_call_mute_status(TapiHandle *handle, TelSoundMuteStatus_t mute, tapi_response_cb callback, void *user_data )
 909 {
 910         struct tapi_resp_data *evt_cb_data = 0;
 911         char *method = 0;
 912
 913         dbg("Func Entrance ");
 914
 915         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 916
 917         if ( mute == TAPI_SOUND_MUTE_STATUS_ON )
 918                 method = "Mute";
 919         else
 920                 method = "Unmute";
 921
 922         g_dbus_connection_call(handle->dbus_connection,
 923                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 924                         method, 0, 0,
 925                         G_DBUS_CALL_FLAGS_NONE, -1, 0,
 926                         on_response_set_call_mute_status, evt_cb_data );
 927
 928         return TAPI_API_SUCCESS;
 929 }
 930
 931 EXPORT_API int tel_get_call_mute_status(TapiHandle *handle, tapi_response_cb callback, void *user_data )
 932 {
 933         struct tapi_resp_data *evt_cb_data = 0;
 934
 935         dbg("Func Entrance ");
 936
 937         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 938
 939         g_dbus_connection_call(handle->dbus_connection,
 940                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 941                         "GetMuteStatus", 0, 0,
 942                         G_DBUS_CALL_FLAGS_NONE, -1, 0,
 943                         on_response_get_call_mute_status, evt_cb_data );
 944
 945         return TAPI_API_SUCCESS;
 946 }
 947
 948 EXPORT_API  int tel_set_call_sound_recording(TapiHandle *handle, TelSoundRecording_t *on, tapi_response_cb callback, void *user_data)
 949 {
 950         struct tapi_resp_data *evt_cb_data = 0;
 951         GVariant *param = 0;
 952
 953         dbg("Func Entrance ");
 954
 955         param = g_variant_new("(i)", on);
 956
 957         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 958
 959         g_dbus_connection_call(handle->dbus_connection,
 960                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 961                         "SetSoundRecording", param, 0,
 962                         G_DBUS_CALL_FLAGS_NONE, -1, 0,
 963                         on_response_set_call_sound_recording, evt_cb_data );
 964
 965         return TAPI_API_SUCCESS;
 966 }
 967
 968 EXPORT_API  int tel_set_call_sound_equalization(TapiHandle *handle, TelCallSoundEqualization_t *eq, tapi_response_cb callback, void *user_data)
 969 {
 970         struct tapi_resp_data *evt_cb_data = 0;
 971         GVariant *param = 0;
 972         char *eq_param = 0;
 973
 974         dbg("Func Entrance ");
 975
 976         eq_param = (char*)eq->parameter;
 977
 978         param = g_variant_new("(iis)", eq->mode, eq->direction, eq_param);
 979
 980         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 981
 982         g_dbus_connection_call(handle->dbus_connection,
 983                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
 984                         "SetSoundEqualization", param, 0,
 985                         G_DBUS_CALL_FLAGS_NONE, -1, 0,
 986                         on_response_set_call_sound_equalization, evt_cb_data );
 987
 988         return TAPI_API_SUCCESS;
 989 }
 990
 991 EXPORT_API  int tel_set_call_sound_noise_reduction(TapiHandle *handle, TelSoundNoiseReduction_t noise, tapi_response_cb callback, void *user_data)
 992 {
 993         struct tapi_resp_data *evt_cb_data = 0;
 994         GVariant *param = 0;
 995
 996         dbg("Func Entrance ");
 997
 998         param = g_variant_new("(i)", noise);
 999
1000         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1001
1002         g_dbus_connection_call(handle->dbus_connection,
1003                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
1004                         "SetSoundNoiseReduction", param, 0,
1005                         G_DBUS_CALL_FLAGS_NONE, -1, 0,
1006                         on_response_set_call_sound_noise_reduction, evt_cb_data );
1007
1008         return TAPI_API_SUCCESS;
1009 }
1010
1011 EXPORT_API int tel_set_call_sound_clock_status(TapiHandle *handle, gboolean status, tapi_response_cb callback, void *user_data )
1012 {
1013         struct tapi_resp_data *evt_cb_data = 0;
1014         GVariant *param = 0;
1015
1016         dbg("Func Entrance");
1017
1018         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1019
1020         param = g_variant_new("(b)", status);
1021
1022         g_dbus_connection_call(handle->dbus_connection,
1023                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
1024                         "SetSoundClockStatus", param, 0,
1025                         G_DBUS_CALL_FLAGS_NONE, -1, 0,
1026                         on_response_set_call_sound_clock_status, evt_cb_data );
1027
1028         return TAPI_API_SUCCESS;
1029 }
1030
1031
1032 /*      EOF  */
1033