4 * Copyright (c) 2011 Samsung Electronics Co., Ltd. All rights reserved.
6 * Contact: Ja-young Gu <jygu@samsung.com>
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
12 * http://www.apache.org/licenses/LICENSE-2.0
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.
26 #include "tapi_common.h"
27 #include "TapiUtility.h"
31 #include "ITapiCall.h"
33 static void on_response_call_dial(GObject *source_object, GAsyncResult *res, gpointer user_data)
36 GDBusConnection *conn = 0;
37 struct tapi_resp_data *evt_cb_data = user_data;
40 GVariant *dbus_result;
44 conn = G_DBUS_CONNECTION (source_object);
45 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
47 g_variant_get (dbus_result, "(i)", &result);
48 if (result != TAPI_CAUSE_SUCCESS)
49 dbg("Modem dialing failed");
51 if (evt_cb_data->cb_fn) {
52 evt_cb_data->cb_fn(evt_cb_data->handle, result, 0, evt_cb_data->user_data);
57 static void on_response_call_answer(GObject *source_object, GAsyncResult *res, gpointer user_data)
60 GDBusConnection *conn = 0;
61 struct tapi_resp_data *evt_cb_data = user_data;
63 TelCallAnswerCnf_t data;
65 GVariant *dbus_result;
67 conn = G_DBUS_CONNECTION (source_object);
68 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
70 g_variant_get (dbus_result, "(ii)", &result, &data.id);
72 if (evt_cb_data->cb_fn) {
73 evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
77 static void on_response_call_end(GObject *source_object, GAsyncResult *res, gpointer user_data)
80 GDBusConnection *conn = 0;
81 struct tapi_resp_data *evt_cb_data = user_data;
85 GVariant *dbus_result;
87 conn = G_DBUS_CONNECTION (source_object);
88 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
90 g_variant_get (dbus_result, "(iii)", &result, &data.id, &data.type);
92 if (evt_cb_data->cb_fn) {
93 evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
97 static void on_response_call_hold(GObject *source_object, GAsyncResult *res, gpointer user_data)
100 GDBusConnection *conn = 0;
101 struct tapi_resp_data *evt_cb_data = user_data;
103 TelCallHoldCnf_t data;
105 GVariant *dbus_result;
107 conn = G_DBUS_CONNECTION (source_object);
108 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
110 g_variant_get (dbus_result, "(ii)", &result, &data.id);
112 if (evt_cb_data->cb_fn) {
113 evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
118 static void on_response_call_active(GObject *source_object, GAsyncResult *res, gpointer user_data)
121 GDBusConnection *conn = 0;
122 struct tapi_resp_data *evt_cb_data = user_data;
124 TelCallActiveCnf_t data;
126 GVariant *dbus_result;
128 conn = G_DBUS_CONNECTION (source_object);
129 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
131 g_variant_get (dbus_result, "(ii)", &result, &data.id);
133 if (evt_cb_data->cb_fn) {
134 evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
140 static void on_response_call_swap(GObject *source_object, GAsyncResult *res, gpointer user_data)
143 GDBusConnection *conn = 0;
144 struct tapi_resp_data *evt_cb_data = user_data;
146 TelCallSwapCnf_t data;
148 GVariant *dbus_result;
150 conn = G_DBUS_CONNECTION (source_object);
151 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
153 g_variant_get (dbus_result, "(ii)", &result, &data.id);
155 if (evt_cb_data->cb_fn) {
156 evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
160 static void on_response_call_join(GObject *source_object, GAsyncResult *res, gpointer user_data)
163 GDBusConnection *conn = 0;
164 struct tapi_resp_data *evt_cb_data = user_data;
166 TelCallJoinCnf_t data;
168 GVariant *dbus_result;
170 conn = G_DBUS_CONNECTION (source_object);
171 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
173 g_variant_get (dbus_result, "(ii)", &result, &data.id);
175 if (evt_cb_data->cb_fn) {
176 evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
180 static void on_response_call_split(GObject *source_object, GAsyncResult *res, gpointer user_data)
183 GDBusConnection *conn = 0;
184 struct tapi_resp_data *evt_cb_data = user_data;
186 TelCallSplitCnf_t data;
188 GVariant *dbus_result;
190 conn = G_DBUS_CONNECTION (source_object);
191 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
193 g_variant_get (dbus_result, "(ii)", &result, &data.id);
195 if (evt_cb_data->cb_fn) {
196 evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
200 static void on_response_call_transfer(GObject *source_object, GAsyncResult *res, gpointer user_data)
203 GDBusConnection *conn = 0;
204 struct tapi_resp_data *evt_cb_data = user_data;
206 TelCallTransferCnf_t data;
208 GVariant *dbus_result;
210 conn = G_DBUS_CONNECTION (source_object);
211 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
213 g_variant_get (dbus_result, "(ii)", &result, &data.id);
215 if (evt_cb_data->cb_fn) {
216 evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
220 static void on_response_call_dtmf(GObject *source_object, GAsyncResult *res, gpointer user_data)
223 GDBusConnection *conn = 0;
224 struct tapi_resp_data *evt_cb_data = user_data;
227 GVariant *dbus_result;
229 conn = G_DBUS_CONNECTION (source_object);
230 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
232 g_variant_get (dbus_result, "(i)", &result);
234 if (evt_cb_data->cb_fn) {
235 evt_cb_data->cb_fn(evt_cb_data->handle, result, 0, evt_cb_data->user_data);
239 static void on_response_call_deflect(GObject *source_object, GAsyncResult *res, gpointer user_data)
242 GDBusConnection *conn = 0;
243 struct tapi_resp_data *evt_cb_data = user_data;
246 GVariant *dbus_result;
248 conn = G_DBUS_CONNECTION (source_object);
249 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
251 g_variant_get (dbus_result, "(i)", &result);
253 if (evt_cb_data->cb_fn) {
254 evt_cb_data->cb_fn(evt_cb_data->handle, result, 0, evt_cb_data->user_data);
258 static void on_response_get_call_volume_info(GObject *source_object, GAsyncResult *res, gpointer user_data)
261 GDBusConnection *conn = 0;
262 struct tapi_resp_data *evt_cb_data = user_data;
263 int result = -1, i = 0;
264 TelCallGetVolumeInfoResp_t resp;
266 GVariant *dbus_result = 0, *value = 0;
267 GVariantIter *iter = 0;
268 GVariantIter *iter_row = 0;
269 const gchar *key = 0;
272 memset(&resp, '\0', sizeof(TelCallGetVolumeInfoResp_t));
274 conn = G_DBUS_CONNECTION (source_object);
275 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
277 g_variant_get (dbus_result, "(aa{sv}i)", &iter, &result);
279 resp.record_num = g_variant_iter_n_children(iter);
281 while ( g_variant_iter_next(iter, "a{sv}", &iter_row ) ) {
282 while ( g_variant_iter_loop( iter_row, "{sv}", &key, &value ) ) {
284 if ( !g_strcmp0(key, "type") ) {
285 int type = g_variant_get_int32(value);
287 resp.record[i].device = (type & 0xf0);
288 resp.record[i].type = (type & 0x0f);
291 if ( !g_strcmp0(key, "level") ) {
292 resp.record[i].volume = g_variant_get_int32(value);
296 g_variant_iter_free(iter_row);
298 g_variant_iter_free(iter);
300 if (evt_cb_data->cb_fn) {
301 evt_cb_data->cb_fn(evt_cb_data->handle, result, &resp, evt_cb_data->user_data);
305 static void on_response_set_call_volume_info(GObject *source_object, GAsyncResult *res, gpointer user_data)
308 GDBusConnection *conn = 0;
309 struct tapi_resp_data *evt_cb_data = user_data;
312 GVariant *dbus_result;
314 conn = G_DBUS_CONNECTION (source_object);
315 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
317 g_variant_get (dbus_result, "(i)", &result);
319 if (evt_cb_data->cb_fn) {
320 evt_cb_data->cb_fn(evt_cb_data->handle, result, 0, evt_cb_data->user_data);
324 static void on_response_set_call_sound_path(GObject *source_object, GAsyncResult *res, gpointer user_data)
327 GDBusConnection *conn = 0;
328 struct tapi_resp_data *evt_cb_data = user_data;
331 GVariant *dbus_result;
333 conn = G_DBUS_CONNECTION (source_object);
334 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
336 g_variant_get (dbus_result, "(i)", &result);
338 if (evt_cb_data->cb_fn) {
339 evt_cb_data->cb_fn(evt_cb_data->handle, result, 0, evt_cb_data->user_data);
343 static void on_response_set_call_mute_status(GObject *source_object, GAsyncResult *res, gpointer user_data)
346 GDBusConnection *conn = 0;
347 struct tapi_resp_data *evt_cb_data = user_data;
350 GVariant *dbus_result;
352 conn = G_DBUS_CONNECTION (source_object);
353 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
355 g_variant_get (dbus_result, "(i)", &result);
357 if (evt_cb_data->cb_fn) {
358 evt_cb_data->cb_fn(evt_cb_data->handle, result, 0, evt_cb_data->user_data);
362 static void on_response_get_call_mute_status(GObject *source_object, GAsyncResult *res, gpointer user_data)
365 GDBusConnection *conn = 0;
366 struct tapi_resp_data *evt_cb_data = user_data;
367 int result = -1, status = 0;
368 TelCallGetMuteStatusResp_t resp;
370 GVariant *dbus_result;
372 conn = G_DBUS_CONNECTION (source_object);
373 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
375 g_variant_get (dbus_result, "(ii)", &result, &resp.status);
377 if (evt_cb_data->cb_fn) {
378 evt_cb_data->cb_fn(evt_cb_data->handle, result, &status, evt_cb_data->user_data);
382 static void on_response_set_call_sound_recording(GObject *source_object, GAsyncResult *res, gpointer user_data)
385 GDBusConnection *conn = 0;
386 struct tapi_resp_data *evt_cb_data = user_data;
389 GVariant *dbus_result;
391 conn = G_DBUS_CONNECTION (source_object);
392 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
394 g_variant_get (dbus_result, "(i)", &result);
396 if (evt_cb_data->cb_fn) {
397 evt_cb_data->cb_fn(evt_cb_data->handle, result, 0, evt_cb_data->user_data);
401 static void on_response_set_call_sound_equalization(GObject *source_object, GAsyncResult *res, gpointer user_data)
404 GDBusConnection *conn = 0;
405 struct tapi_resp_data *evt_cb_data = user_data;
408 GVariant *dbus_result;
410 conn = G_DBUS_CONNECTION (source_object);
411 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
413 g_variant_get (dbus_result, "(i)", &result);
415 if (evt_cb_data->cb_fn) {
416 evt_cb_data->cb_fn(evt_cb_data->handle, result, 0, evt_cb_data->user_data);
420 static void on_response_set_call_sound_noise_reduction(GObject *source_object, GAsyncResult *res, gpointer user_data)
423 GDBusConnection *conn = 0;
424 struct tapi_resp_data *evt_cb_data = user_data;
427 GVariant *dbus_result;
429 conn = G_DBUS_CONNECTION (source_object);
430 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
432 g_variant_get (dbus_result, "(i)", &result);
434 if (evt_cb_data->cb_fn) {
435 evt_cb_data->cb_fn(evt_cb_data->handle, result, 0, evt_cb_data->user_data);
439 static void on_response_set_call_sound_clock_status(GObject *source_object, GAsyncResult *res, gpointer user_data)
442 GDBusConnection *conn = 0;
443 struct tapi_resp_data *evt_cb_data = user_data;
446 GVariant *dbus_result;
448 conn = G_DBUS_CONNECTION (source_object);
449 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
451 g_variant_get (dbus_result, "(i)", &result);
453 if (evt_cb_data->cb_fn) {
454 evt_cb_data->cb_fn(evt_cb_data->handle, result, 0, evt_cb_data->user_data);
459 EXPORT_API int tel_dial_call(TapiHandle *handle, const TelCallDial_t *pParams, tapi_response_cb callback, void *user_data)
461 struct tapi_resp_data *evt_cb_data = 0;
464 dbg("Func Entrance");
466 return TAPI_API_INVALID_INPUT;
468 dbg("Destination Number : %s", pParams->szNumber);
470 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
472 param = g_variant_new("(is)", pParams->CallType, pParams->szNumber);
474 g_dbus_connection_call(handle->dbus_connection,
475 DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
477 G_DBUS_CALL_FLAGS_NONE, -1, 0,
478 on_response_call_dial, evt_cb_data );
480 return TAPI_API_SUCCESS;
484 EXPORT_API int tel_answer_call(TapiHandle *handle, unsigned int CallHandle, TelCallAnswerType_t AnsType, tapi_response_cb callback, void *user_data )
486 struct tapi_resp_data *evt_cb_data = 0;
489 dbg("Func Entrance ");
491 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
493 param = g_variant_new("(ii)", CallHandle, AnsType);
495 g_dbus_connection_call(handle->dbus_connection,
496 DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
498 G_DBUS_CALL_FLAGS_NONE, -1, 0,
499 on_response_call_answer, evt_cb_data );
501 return TAPI_API_SUCCESS;
504 EXPORT_API int tel_end_call(TapiHandle *handle, unsigned int CallHandle, TelCallEndType_t EndType, tapi_response_cb callback, void *user_data)
506 struct tapi_resp_data *evt_cb_data = 0;
509 dbg("Func Entrance ");
511 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
513 param = g_variant_new("(ii)", CallHandle, EndType);
515 g_dbus_connection_call(handle->dbus_connection,
516 DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
518 G_DBUS_CALL_FLAGS_NONE, -1, 0,
519 on_response_call_end, evt_cb_data );
521 return TAPI_API_SUCCESS;
524 EXPORT_API int tel_hold_call(TapiHandle *handle, unsigned int CallHandle, tapi_response_cb callback, void *user_data )
526 struct tapi_resp_data *evt_cb_data = 0;
529 dbg("Func Entrance ");
531 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
533 param = g_variant_new("(i)", CallHandle);
535 g_dbus_connection_call(handle->dbus_connection,
536 DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
538 G_DBUS_CALL_FLAGS_NONE, -1, 0,
539 on_response_call_hold, evt_cb_data );
541 return TAPI_API_SUCCESS;
544 EXPORT_API int tel_active_call(TapiHandle *handle, unsigned int CallHandle, tapi_response_cb callback, void *user_data )
546 struct tapi_resp_data *evt_cb_data = 0;
549 dbg("Func Entrance ");
551 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
553 param = g_variant_new("(i)", CallHandle);
555 g_dbus_connection_call(handle->dbus_connection,
556 DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
558 G_DBUS_CALL_FLAGS_NONE, -1, 0,
559 on_response_call_active, evt_cb_data );
561 return TAPI_API_SUCCESS;
564 EXPORT_API int tel_swap_call(TapiHandle *handle, unsigned int CallHandle1, unsigned int CallHandle2, tapi_response_cb callback, void *user_data )
566 struct tapi_resp_data *evt_cb_data = 0;
569 dbg("Func Entrance ");
571 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
573 param = g_variant_new("(i)", CallHandle1, CallHandle2);
575 g_dbus_connection_call(handle->dbus_connection,
576 DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
578 G_DBUS_CALL_FLAGS_NONE, -1, 0,
579 on_response_call_swap, evt_cb_data );
581 return TAPI_API_SUCCESS;
584 EXPORT_API int tel_join_call(TapiHandle *handle, unsigned int CallHandle1, unsigned int CallHandle2, tapi_response_cb callback, void *user_data )
586 struct tapi_resp_data *evt_cb_data = 0;
589 dbg("Func Entrance ");
591 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
593 param = g_variant_new("(i)", CallHandle1, CallHandle2);
595 g_dbus_connection_call(handle->dbus_connection,
596 DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
598 G_DBUS_CALL_FLAGS_NONE, -1, 0,
599 on_response_call_join, evt_cb_data );
601 return TAPI_API_SUCCESS;
604 EXPORT_API int tel_split_call(TapiHandle *handle, unsigned int CallHandle, tapi_response_cb callback, void *user_data )
606 struct tapi_resp_data *evt_cb_data = 0;
609 dbg("Func Entrance ");
611 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
613 param = g_variant_new("(i)", CallHandle);
615 g_dbus_connection_call(handle->dbus_connection,
616 DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
618 G_DBUS_CALL_FLAGS_NONE, -1, 0,
619 on_response_call_split, evt_cb_data );
621 return TAPI_API_SUCCESS;
624 EXPORT_API int tel_transfer_call(TapiHandle *handle, unsigned int CallHandle, tapi_response_cb callback, void *user_data )
626 struct tapi_resp_data *evt_cb_data = 0;
629 dbg("Func Entrance ");
631 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
633 param = g_variant_new("(i)", CallHandle);
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 );
641 return TAPI_API_SUCCESS;
644 EXPORT_API int tel_activate_call_ccbs(TapiHandle *handle, unsigned int CallHandle, tapi_response_cb callback, void *user_data )
646 return TAPI_API_SUCCESS;
649 EXPORT_API int tel_call_dtmf(TapiHandle *handle, const char *pDtmfString, tapi_response_cb callback, void *user_data )
651 struct tapi_resp_data *evt_cb_data = 0;
654 dbg("Func Entrance ");
656 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
658 param = g_variant_new("(s)", pDtmfString);
660 g_dbus_connection_call(handle->dbus_connection,
661 DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
663 G_DBUS_CALL_FLAGS_NONE, -1, 0,
664 on_response_call_dtmf, evt_cb_data );
666 return TAPI_API_SUCCESS;
669 EXPORT_API int tel_deflect_call(TapiHandle *handle, unsigned int CallHandle, const TelCallDeflectDstInfo_t *pInfo, tapi_response_cb callback, void *user_data )
671 struct tapi_resp_data *evt_cb_data = 0;
674 dbg("Func Entrance ");
676 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
678 param = g_variant_new("(is)", CallHandle, pInfo->number);
680 g_dbus_connection_call(handle->dbus_connection,
681 DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
683 G_DBUS_CALL_FLAGS_NONE, -1, 0,
684 on_response_call_deflect, evt_cb_data );
686 return TAPI_API_SUCCESS;
689 EXPORT_API int tel_get_call_status(TapiHandle *handle, int call_id, TelCallStatus_t *out )
698 gboolean call_direction = FALSE;
700 gboolean call_multiparty_state = FALSE;
703 dbg("[ error ] out : 0 ");
704 return TAPI_API_INVALID_INPUT;
707 param = g_variant_new("(i)", call_id);
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);
714 g_variant_get(gv, "(isibib)", &call_id, &call_number, &call_type, &call_direction, &call_state, &call_multiparty_state);
716 out->CallHandle = (int)call_id;
717 out->bMoCall = (int)call_direction;
718 strncpy( out->pNumber, call_number, TAPI_CALL_DIALDIGIT_LEN_MAX );
720 dbg("[ check ] call_number : %s", call_number);
721 dbg("[ check ] out->pNumber : %s", out->pNumber);
723 out->CallType = (TelCallType_t)call_type;
724 out->CallState = (TelCallStates_t)call_state;
725 out->bConferenceState = (int)call_multiparty_state;
727 g_free( call_number );
731 dbg("[ error ] fail to get call status : (0x%x)", call_id);
732 return TAPI_API_OPERATION_FAILED;
735 return TAPI_API_SUCCESS;
738 EXPORT_API int tel_get_call_status_all( TapiHandle *handle, TelCallStatusCallback cb, void *user_data )
741 GVariantIter *iter = 0, *iter_row = 0;
745 dbg("[ error ] out : 0 ");
746 return TAPI_API_INVALID_INPUT;
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);
755 TelCallStatus_t data;
759 g_variant_get(gv, "(aa{sv})", &iter);
761 while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
763 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
765 if (!g_strcmp0(key, "call_id")) {
766 data.CallHandle = g_variant_get_int32(value);
768 if (!g_strcmp0(key, "call_number")) {
769 strncpy(data.pNumber, g_variant_get_string(value, 0), TAPI_CALL_DIALDIGIT_LEN_MAX);
771 if (!g_strcmp0(key, "call_type")) {
772 data.CallType = (int)g_variant_get_int32(value);
774 if (!g_strcmp0(key, "call_direction")) {
775 data.bMoCall = (int)g_variant_get_boolean(value);
777 if (!g_strcmp0(key, "call_state")) {
778 data.CallState = (int)g_variant_get_int32(value);
780 if (!g_strcmp0(key, "call_multiparty_state")) {
781 data.bConferenceState = (int)g_variant_get_boolean(value);
786 g_variant_iter_free(iter_row);
788 cb( &data, user_data );
790 g_variant_iter_free(iter);
793 dbg("[ error ] fail to get call status");
794 return TAPI_API_OPERATION_FAILED;
798 return TAPI_API_SUCCESS;
801 EXPORT_API int tel_get_call_act_line(TapiHandle *handle, tapi_response_cb callback, void *user_data )
803 return TAPI_API_SUCCESS;
806 EXPORT_API int tel_set_call_act_line(TapiHandle *handle, TelCallActiveLine_t active_line, tapi_response_cb callback, void *user_data )
808 return TAPI_API_SUCCESS;
811 /*================================================================================================*/
813 EXPORT_API int tel_get_call_duration(TapiHandle *handle, unsigned int CallHandle, unsigned int *pDurationInSecs)
815 return TAPI_API_SUCCESS;
818 EXPORT_API int tel_get_call_conf_list(TapiHandle *handle, unsigned int CallHandle, unsigned int *pCallList, int *pNoOfCalls)
820 return TAPI_API_SUCCESS;
823 EXPORT_API int tel_get_call_privacy_mode(TapiHandle *handle, TelCallPrivacyType_t PrivacyType, tapi_response_cb callback, void *user_data )
825 return TAPI_API_SUCCESS;
828 EXPORT_API int tel_set_call_privacy_mode(TapiHandle *handle, TelCallVoicePrivacyInfo_t PrivacyInfo, tapi_response_cb callback, void *user_data )
830 return TAPI_API_SUCCESS;
833 EXPORT_API int tel_exe_call_flash_info(TapiHandle *handle, const char *pDialNumber, tapi_response_cb callback, void *user_data )
835 return TAPI_API_SUCCESS;
838 EXPORT_API int tel_exit_call_emergency_mode(TapiHandle *handle, tapi_response_cb callback, void *user_data )
840 return TAPI_API_SUCCESS;
843 EXPORT_API int tel_get_call_time(TapiHandle *handle, unsigned short req_mask, tapi_response_cb callback, void *user_data )
845 return TAPI_API_SUCCESS;
848 EXPORT_API int tel_get_call_volume_info(TapiHandle *handle, TelSoundDevice_t device, TelSoundType_t type, tapi_response_cb callback, void *user_data )
850 struct tapi_resp_data *evt_cb_data = 0;
853 dbg("Func Entrance ");
855 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
857 param = g_variant_new("(ii)", device, type);
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 );
865 return TAPI_API_SUCCESS;
868 EXPORT_API int tel_set_call_volume_info(TapiHandle *handle, TelCallVolumeInfo_t *info, tapi_response_cb callback, void *user_data )
870 struct tapi_resp_data *evt_cb_data = 0;
873 dbg("Func Entrance ");
875 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
877 param = g_variant_new("(iii)", info->device, info->type, info->volume);
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 );
885 return TAPI_API_SUCCESS;
888 EXPORT_API int tel_set_call_sound_path(TapiHandle *handle, TelCallSoundPathInfo_t *info, tapi_response_cb callback, void *user_data )
890 struct tapi_resp_data *evt_cb_data = 0;
893 dbg("Func Entrance ");
895 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
897 param = g_variant_new("(ib)", info->path, info->ex_volume);
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 );
905 return TAPI_API_SUCCESS;
908 EXPORT_API int tel_set_call_mute_status(TapiHandle *handle, TelSoundMuteStatus_t mute, tapi_response_cb callback, void *user_data )
910 struct tapi_resp_data *evt_cb_data = 0;
913 dbg("Func Entrance ");
915 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
917 if ( mute == TAPI_SOUND_MUTE_STATUS_ON )
922 g_dbus_connection_call(handle->dbus_connection,
923 DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_CALL_INTERFACE,
925 G_DBUS_CALL_FLAGS_NONE, -1, 0,
926 on_response_set_call_mute_status, evt_cb_data );
928 return TAPI_API_SUCCESS;
931 EXPORT_API int tel_get_call_mute_status(TapiHandle *handle, tapi_response_cb callback, void *user_data )
933 struct tapi_resp_data *evt_cb_data = 0;
935 dbg("Func Entrance ");
937 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
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 );
945 return TAPI_API_SUCCESS;
948 EXPORT_API int tel_set_call_sound_recording(TapiHandle *handle, TelSoundRecording_t *on, tapi_response_cb callback, void *user_data)
950 struct tapi_resp_data *evt_cb_data = 0;
953 dbg("Func Entrance ");
955 param = g_variant_new("(i)", on);
957 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
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 );
965 return TAPI_API_SUCCESS;
968 EXPORT_API int tel_set_call_sound_equalization(TapiHandle *handle, TelCallSoundEqualization_t *eq, tapi_response_cb callback, void *user_data)
970 struct tapi_resp_data *evt_cb_data = 0;
974 dbg("Func Entrance ");
976 eq_param = (char*)eq->parameter;
978 param = g_variant_new("(iis)", eq->mode, eq->direction, eq_param);
980 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
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 );
988 return TAPI_API_SUCCESS;
991 EXPORT_API int tel_set_call_sound_noise_reduction(TapiHandle *handle, TelSoundNoiseReduction_t noise, tapi_response_cb callback, void *user_data)
993 struct tapi_resp_data *evt_cb_data = 0;
996 dbg("Func Entrance ");
998 param = g_variant_new("(i)", noise);
1000 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
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 );
1008 return TAPI_API_SUCCESS;
1011 EXPORT_API int tel_set_call_sound_clock_status(TapiHandle *handle, gboolean status, tapi_response_cb callback, void *user_data )
1013 struct tapi_resp_data *evt_cb_data = 0;
1014 GVariant *param = 0;
1016 dbg("Func Entrance");
1018 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1020 param = g_variant_new("(b)", status);
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 );
1028 return TAPI_API_SUCCESS;