4 * Copyright (c) 2014 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.
25 #include "tapi_common.h"
26 #include "TapiUtility.h"
31 #include "ITapiNetText.h"
33 static void on_response_default(GObject *source_object, GAsyncResult *res, gpointer user_data)
36 GDBusConnection *conn = NULL;
37 struct tapi_resp_data *evt_cb_data = user_data;
40 GVariant *dbus_result = NULL;
43 conn = G_DBUS_CONNECTION (source_object);
44 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
47 dbg("on_response_default type_format(%s)", g_variant_get_type_string(dbus_result));
49 g_variant_get (dbus_result, "(i)", &result);
52 if (evt_cb_data->cb_fn) {
53 evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
58 g_variant_unref(dbus_result);
61 static void on_response_read_msg(GObject *source_object, GAsyncResult *res, gpointer user_data)
64 GDBusConnection *conn = NULL;
65 struct tapi_resp_data *evt_cb_data = user_data;
68 TelSmsData_t readMsg = {0,};
69 GVariant *dbus_result = NULL;
71 GVariant *sca = 0, *tpdu = 0;
73 GVariantIter *iter = 0;
74 GVariant *inner_gv = 0;
76 conn = G_DBUS_CONNECTION (source_object);
77 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
80 dbg("on_response_read_msg type_format(%s)", g_variant_get_type_string(dbus_result));
82 // readMsg.SimIndex = 0xFFFFFFFF;
83 g_variant_get (dbus_result, "(iii@vi@v)", &result,
87 &readMsg.SmsData.MsgLength,
90 inner_gv = g_variant_get_variant( sca );
91 g_variant_get(inner_gv, "ay", &iter);
92 while( g_variant_iter_loop(iter, "y", &readMsg.SmsData.Sca[i] ) ) {
94 if( i >= TAPI_SIM_SMSP_ADDRESS_LEN )
98 inner_gv = g_variant_get_variant( tpdu );
99 g_variant_get(inner_gv, "ay", &iter);
101 while( g_variant_iter_loop(iter, "y", &readMsg.SmsData.szData[i]) ) {
103 if( i >= TAPI_NETTEXT_SMDATA_SIZE_MAX + 1 )
106 g_variant_iter_free(iter);
107 g_variant_unref(inner_gv);
110 if (evt_cb_data->cb_fn) {
111 evt_cb_data->cb_fn(evt_cb_data->handle, result, &readMsg, evt_cb_data->user_data);
116 g_variant_unref(dbus_result);
119 static void on_response_write_msg(GObject *source_object, GAsyncResult *res, gpointer user_data)
121 GError *error = NULL;
122 GDBusConnection *conn = NULL;
123 struct tapi_resp_data *evt_cb_data = user_data;
127 GVariant *dbus_result = NULL;
129 conn = G_DBUS_CONNECTION (source_object);
130 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
133 dbg("on_response_write_msg type_format(%s)", g_variant_get_type_string(dbus_result));
135 g_variant_get (dbus_result, "(ii)", &result, &sms_index);
138 if (evt_cb_data->cb_fn) {
139 evt_cb_data->cb_fn(evt_cb_data->handle, result, &sms_index, evt_cb_data->user_data);
144 g_variant_unref(dbus_result);
147 static void on_response_delete_msg(GObject *source_object, GAsyncResult *res, gpointer user_data)
149 GError *error = NULL;
150 GDBusConnection *conn = NULL;
151 struct tapi_resp_data *evt_cb_data = user_data;
155 GVariant *dbus_result = NULL;
157 conn = G_DBUS_CONNECTION (source_object);
158 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
161 dbg("on_response_delete_msg type_format(%s)", g_variant_get_type_string(dbus_result));
163 g_variant_get (dbus_result, "(ii)", &result, &del_index);
166 if (evt_cb_data->cb_fn) {
167 evt_cb_data->cb_fn(evt_cb_data->handle, result, &del_index, evt_cb_data->user_data);
172 g_variant_unref(dbus_result);
175 static void on_response_get_msg_count(GObject *source_object, GAsyncResult *res, gpointer user_data)
177 GError *error = NULL;
178 GDBusConnection *conn = NULL;
179 struct tapi_resp_data *evt_cb_data = user_data;
181 TelSmsStoredMsgCountInfo_t storedMsgCnt = {0,};
183 GVariant *dbus_result = NULL;
186 GVariantIter *iter = NULL;
188 conn = G_DBUS_CONNECTION (source_object);
189 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
192 dbg("on_response_get_msg_count type_format(%s)", g_variant_get_type_string(dbus_result));
194 g_variant_get (dbus_result, "(iiiai)", &result,
195 &storedMsgCnt.TotalCount,
196 &storedMsgCnt.UsedCount,
200 while (g_variant_iter_loop(iter, "i", &idx)) {
201 storedMsgCnt.IndexList[i] = idx;
203 if (i >= TAPI_NETTEXT_SMS_MSG_NUM_MAX)
208 if (evt_cb_data->cb_fn) {
209 evt_cb_data->cb_fn(evt_cb_data->handle, result, &storedMsgCnt, evt_cb_data->user_data);
214 g_variant_unref(dbus_result);
217 static void on_response_get_sca(GObject *source_object, GAsyncResult *res, gpointer user_data)
219 GError *error = NULL;
220 GDBusConnection *conn = NULL;
221 struct tapi_resp_data *evt_cb_data = user_data;
223 TelSmsAddressInfo_t scaInfo = {0,};
225 GVariant *dbus_result = NULL;
229 GVariantIter *iter = 0;
230 GVariant *inner_gv = 0;
233 conn = G_DBUS_CONNECTION (source_object);
234 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
237 dbg("on_response_get_sca type_format(%s)", g_variant_get_type_string(dbus_result));
239 g_variant_get (dbus_result, "(iiii@v)", &result,
245 inner_gv = g_variant_get_variant( num );
246 g_variant_get(inner_gv, "ay", &iter);
247 while( g_variant_iter_loop(iter, "y", &scaInfo.szDiallingNum[i] ) ) {
249 if( i >= TAPI_SIM_SMSP_ADDRESS_LEN + 1 )
252 g_variant_iter_free(iter);
253 g_variant_unref(inner_gv);
256 if (evt_cb_data->cb_fn) {
257 evt_cb_data->cb_fn(evt_cb_data->handle, result, &scaInfo, evt_cb_data->user_data);
262 g_variant_unref(dbus_result);
265 static void on_response_get_cb_config(GObject *source_object, GAsyncResult *res, gpointer user_data)
267 GError *error = NULL;
268 GDBusConnection *conn = NULL;
269 struct tapi_resp_data *evt_cb_data = user_data;
272 TelSmsCbConfig_t cbConfig = {0,};
274 GVariant *dbus_result = NULL;
275 GVariant *value = NULL;
276 GVariantIter *iter = NULL;
277 GVariantIter *iter_row = NULL;
278 const gchar *key = NULL;
280 conn = G_DBUS_CONNECTION (source_object);
281 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
284 dbg("on_response_get_cb_config type_format(%s)", g_variant_get_type_string(dbus_result));
286 g_variant_get (dbus_result, "(iiiiiaa{sv})", &result,
287 &cbConfig.Net3gppType,
289 &cbConfig.MsgIdMaxCount,
290 &cbConfig.MsgIdRangeCount,
294 while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
295 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
296 if (!g_strcmp0(key, "FromMsgId")) {
297 cbConfig.MsgIDs[i].Net3gpp.FromMsgId = g_variant_get_uint16(value);
299 if (!g_strcmp0(key, "ToMsgId")) {
300 cbConfig.MsgIDs[i].Net3gpp.ToMsgId = g_variant_get_uint16(value);
302 if (!g_strcmp0(key, "CBCategory")) {
303 cbConfig.MsgIDs[i].Net3gpp2.CBCategory = g_variant_get_uint16(value);
305 if (!g_strcmp0(key, "CBLanguage")) {
306 cbConfig.MsgIDs[i].Net3gpp2.CBLanguage = g_variant_get_uint16(value);
308 if (!g_strcmp0(key, "Selected")) {
309 cbConfig.MsgIDs[i].Net3gpp.Selected = g_variant_get_byte(value);
313 g_variant_iter_free(iter_row);
315 g_variant_iter_free(iter);
318 if (evt_cb_data->cb_fn) {
319 evt_cb_data->cb_fn(evt_cb_data->handle, result, &cbConfig, evt_cb_data->user_data);
324 g_variant_unref(dbus_result);
327 static void on_response_get_sms_params(GObject *source_object, GAsyncResult *res, gpointer user_data)
329 GError *error = NULL;
330 GDBusConnection *conn = NULL;
331 struct tapi_resp_data *evt_cb_data = user_data;
333 TelSmsParams_t paramInfo = {0,};
335 GVariant *dbus_result = NULL;
337 GVariant *alphaId = 0, *destDialNum = 0, *scaDialNum = 0;
339 GVariantIter *iter = 0;
340 GVariant *inner_gv = 0;
342 conn = G_DBUS_CONNECTION (source_object);
343 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
346 dbg("on_response_get_sms_params type_format(%s)", g_variant_get_type_string(dbus_result));
348 g_variant_get (dbus_result, "(iiii@viiii@viii@viii)", &result,
349 ¶mInfo.RecordIndex,
350 ¶mInfo.RecordLen,
351 ¶mInfo.AlphaIdLen,
353 ¶mInfo.ParamIndicator,
354 ¶mInfo.TpDestAddr.DialNumLen,
355 ¶mInfo.TpDestAddr.Ton,
356 ¶mInfo.TpDestAddr.Npi,
358 ¶mInfo.TpSvcCntrAddr.DialNumLen,
359 ¶mInfo.TpSvcCntrAddr.Ton,
360 ¶mInfo.TpSvcCntrAddr.Npi,
362 ¶mInfo.TpProtocolId,
363 ¶mInfo.TpDataCodingScheme,
364 ¶mInfo.TpValidityPeriod);
366 inner_gv = g_variant_get_variant( alphaId );
367 g_variant_get(inner_gv, "ay", &iter);
368 while( g_variant_iter_loop(iter, "y", ¶mInfo.szAlphaId[i] ) ) {
370 if( i >= TAPI_SIM_SMSP_ALPHA_ID_LEN_MAX + 1 )
374 inner_gv = g_variant_get_variant( destDialNum );
375 g_variant_get(inner_gv, "ay", &iter);
377 while( g_variant_iter_loop(iter, "y", ¶mInfo.TpDestAddr.szDiallingNum[i] ) ) {
379 if( i >= TAPI_SIM_SMSP_ADDRESS_LEN + 1 )
383 inner_gv = g_variant_get_variant( scaDialNum );
384 g_variant_get(inner_gv, "ay", &iter);
386 while( g_variant_iter_loop(iter, "y", ¶mInfo.TpSvcCntrAddr.szDiallingNum[i] ) ) {
388 if( i >= TAPI_SIM_SMSP_ADDRESS_LEN + 1 )
392 g_variant_iter_free(iter);
393 g_variant_unref(inner_gv);
396 if (evt_cb_data->cb_fn) {
397 evt_cb_data->cb_fn(evt_cb_data->handle, result, ¶mInfo, evt_cb_data->user_data);
402 g_variant_unref(dbus_result);
405 static void on_response_get_sms_param_cnt(GObject *source_object, GAsyncResult *res, gpointer user_data)
407 GError *error = NULL;
408 GDBusConnection *conn = NULL;
409 struct tapi_resp_data *evt_cb_data = user_data;
413 GVariant *dbus_result = NULL;
415 conn = G_DBUS_CONNECTION (source_object);
416 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
419 dbg("on_response_get_sms_param_cnt type_format(%s)", g_variant_get_type_string(dbus_result));
421 g_variant_get (dbus_result, "(ii)", &result,
425 if (evt_cb_data->cb_fn) {
426 evt_cb_data->cb_fn(evt_cb_data->handle, result, &recordCount, evt_cb_data->user_data);
431 g_variant_unref(dbus_result);
434 EXPORT_API int tel_send_sms(struct tapi_handle *handle,
435 const TelSmsDatapackageInfo_t *pDataPackage,
437 tapi_response_cb callback, void* user_data)
439 struct tapi_resp_data *evt_cb_data = NULL;
441 GVariant *sca = 0, *packet_sca = 0;
442 GVariant *tpdu = 0, *packet_tpdu = 0;
446 dbg("Func Entrance ");
448 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
449 TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
450 TAPI_RET_ERR_NUM_IF_FAIL(pDataPackage, TAPI_API_INVALID_PTR);
452 if (pDataPackage->Sca[0] > TAPI_SIM_SMSP_ADDRESS_LEN) {
453 err("Invalid SCA length:[%d]", pDataPackage->Sca[0]);
454 return TAPI_API_INVALID_INPUT;
457 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
459 g_variant_builder_init(&b, G_VARIANT_TYPE("ay") );
460 for( i=0; i<TAPI_SIM_SMSP_ADDRESS_LEN; i++) {
461 g_variant_builder_add(&b, "y", pDataPackage->Sca[i] );
463 sca = g_variant_builder_end(&b);
464 packet_sca = g_variant_new("v", sca);
466 g_variant_builder_init(&b, G_VARIANT_TYPE("ay") );
467 for( i=0; i<TAPI_NETTEXT_SMDATA_SIZE_MAX + 1; i++) {
468 g_variant_builder_add(&b, "y", pDataPackage->szData[i] );
470 tpdu = g_variant_builder_end(&b);
471 packet_tpdu = g_variant_new("v", tpdu);
473 param = g_variant_new("(@vi@vi)", packet_sca,
474 pDataPackage->MsgLength,
478 g_dbus_connection_call(handle->dbus_connection,
479 DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_SMS_INTERFACE,
480 "SendMsg", param, NULL,
481 G_DBUS_CALL_FLAGS_NONE, 120000, handle->ca,
482 on_response_default, evt_cb_data);
484 return TAPI_API_SUCCESS;
487 EXPORT_API int tel_read_sms_in_sim(struct tapi_handle *handle, int read_index, tapi_response_cb callback, void* user_data)
489 struct tapi_resp_data *evt_cb_data = NULL;
492 dbg("Func Entrance ");
494 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
495 TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
497 if( (read_index < 0) || (read_index > TAPI_NETTEXT_MAX_INDEX) ) {
498 err("Invalid Input -Read SMS %d",read_index);
500 return TAPI_API_INVALID_INPUT;
503 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
505 param = g_variant_new("(i)", read_index);
507 g_dbus_connection_call(handle->dbus_connection,
508 DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_SMS_INTERFACE,
509 "ReadMsg", param, NULL,
510 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
511 on_response_read_msg, evt_cb_data);
513 return TAPI_API_SUCCESS;
516 EXPORT_API int tel_write_sms_in_sim(struct tapi_handle *handle, const TelSmsData_t *pWriteData, tapi_response_cb callback, void* user_data)
518 struct tapi_resp_data *evt_cb_data = NULL;
520 GVariant *sca = 0, *packet_sca = 0;
521 GVariant *tpdu = 0, *packet_tpdu = 0;
525 dbg("Func Entrance ");
527 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
528 TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
529 TAPI_RET_ERR_NUM_IF_FAIL(pWriteData, TAPI_API_INVALID_PTR);
531 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
533 g_variant_builder_init(&b, G_VARIANT_TYPE("ay") );
534 for( i=0; i<TAPI_SIM_SMSP_ADDRESS_LEN; i++) {
535 g_variant_builder_add(&b, "y", pWriteData->SmsData.Sca[i] );
537 sca = g_variant_builder_end(&b);
538 packet_sca = g_variant_new("v", sca);
540 g_variant_builder_init(&b, G_VARIANT_TYPE("ay") );
541 for( i=0; i<TAPI_NETTEXT_SMDATA_SIZE_MAX + 1; i++) {
542 g_variant_builder_add(&b, "y", pWriteData->SmsData.szData[i] );
544 tpdu = g_variant_builder_end(&b);
545 packet_tpdu = g_variant_new("v", tpdu);
547 param = g_variant_new("(i@vi@v)", pWriteData->MsgStatus,
549 pWriteData->SmsData.MsgLength,
552 g_dbus_connection_call(handle->dbus_connection,
553 DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_SMS_INTERFACE,
554 "SaveMsg", param, NULL,
555 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
556 on_response_write_msg, evt_cb_data);
558 return TAPI_API_SUCCESS;
561 EXPORT_API int tel_delete_sms_in_sim(struct tapi_handle *handle, int del_index, tapi_response_cb callback, void* user_data)
563 struct tapi_resp_data *evt_cb_data = NULL;
566 dbg("Func Entrance ");
568 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
569 TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
571 if ((del_index < -1) || (del_index > TAPI_NETTEXT_MAX_INDEX)) {
572 err("Invalid Index Input");
573 return TAPI_API_INVALID_INPUT;
576 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
578 param = g_variant_new("(i)", del_index);
580 g_dbus_connection_call(handle->dbus_connection,
581 DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_SMS_INTERFACE,
582 "DeleteMsg", param, NULL,
583 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
584 on_response_delete_msg, evt_cb_data);
586 return TAPI_API_SUCCESS;
589 EXPORT_API int tel_get_sms_count(struct tapi_handle *handle, tapi_response_cb callback, void* user_data)
591 struct tapi_resp_data *evt_cb_data = NULL;
593 dbg("Func Entrance ");
595 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
596 TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
598 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
600 g_dbus_connection_call(handle->dbus_connection,
601 DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_SMS_INTERFACE,
602 "GetMsgCount", NULL, NULL,
603 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
604 on_response_get_msg_count, evt_cb_data);
606 return TAPI_API_SUCCESS;
609 EXPORT_API int tel_get_sms_sca(struct tapi_handle *handle, int sca_index, tapi_response_cb callback, void* user_data)
611 struct tapi_resp_data *evt_cb_data = NULL;
614 dbg("Func Entrance ");
616 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
617 TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
619 if ((sca_index < 0) || (sca_index > TAPI_NETTEXT_MAX_INDEX)) {
620 err("Invalid Index Input");
621 return TAPI_API_INVALID_INPUT;
624 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
626 param = g_variant_new("(i)", sca_index);
628 g_dbus_connection_call(handle->dbus_connection,
629 DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_SMS_INTERFACE,
630 "GetSca", param, NULL,
631 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
632 on_response_get_sca, evt_cb_data);
634 return TAPI_API_SUCCESS;
637 EXPORT_API int tel_set_sms_sca(struct tapi_handle *handle, const TelSmsAddressInfo_t *pSCA, int sca_index, tapi_response_cb callback, void* user_data)
639 struct tapi_resp_data *evt_cb_data = NULL;
641 GVariant *sca = 0, *packet_sca = 0;
645 dbg("Func Entrance ");
647 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
648 TAPI_RET_ERR_NUM_IF_FAIL(pSCA, TAPI_API_INVALID_PTR);
650 if ((sca_index < 0) || (sca_index > TAPI_NETTEXT_MAX_INDEX)) {
651 err("Invalid Index Input");
652 return TAPI_API_INVALID_INPUT;
655 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
657 g_variant_builder_init(&b, G_VARIANT_TYPE("ay") );
658 for( i=0; i<TAPI_SIM_SMSP_ADDRESS_LEN + 1; i++) {
659 g_variant_builder_add(&b, "y", pSCA->szDiallingNum[i] );
661 sca = g_variant_builder_end(&b);
662 packet_sca = g_variant_new("v", sca);
664 param = g_variant_new("(iiii@v)", sca_index,
670 g_dbus_connection_call(handle->dbus_connection,
671 DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_SMS_INTERFACE,
672 "SetSca", param, NULL,
673 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
674 on_response_default, evt_cb_data);
676 return TAPI_API_SUCCESS;
679 EXPORT_API int tel_get_sms_cb_config(struct tapi_handle *handle, tapi_response_cb callback, void* user_data)
681 struct tapi_resp_data *evt_cb_data = NULL;
683 dbg("Func Entrance ");
685 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
686 TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
688 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
690 g_dbus_connection_call(handle->dbus_connection,
691 DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_SMS_INTERFACE,
692 "GetCbConfig", NULL, NULL,
693 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
694 on_response_get_cb_config, evt_cb_data);
696 return TAPI_API_SUCCESS;
699 EXPORT_API int tel_set_sms_cb_config(struct tapi_handle *handle, const TelSmsCbConfig_t *pCBConfig, tapi_response_cb callback, void* user_data)
701 struct tapi_resp_data *evt_cb_data = NULL;
703 GVariant *msgId = 0, *packet_msgId = 0;
707 dbg("Func Entrance ");
709 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
710 TAPI_RET_ERR_NUM_IF_FAIL(pCBConfig, TAPI_API_INVALID_PTR);
712 if ((pCBConfig->Net3gppType > 2) || (pCBConfig->MsgIdRangeCount < 0)) {
713 err("Invalid Input -3gppType(%d)",pCBConfig->Net3gppType);
714 err("Invalid Input -MsgIdRangeCount(%d)",pCBConfig->MsgIdRangeCount);
716 return TAPI_API_INVALID_INPUT;
719 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
721 g_variant_builder_init( &b, G_VARIANT_TYPE("aa{sv}") );
723 for (i = 0; i < pCBConfig->MsgIdRangeCount; i++) {
724 g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
725 if( pCBConfig->Net3gppType == TAPI_NETTEXT_CB_MSG_GSM ) {
726 g_variant_builder_add(&b, "{sv}", "FromMsgId", g_variant_new_uint16(pCBConfig->MsgIDs[i].Net3gpp.FromMsgId));
727 g_variant_builder_add(&b, "{sv}", "ToMsgId", g_variant_new_uint16(pCBConfig->MsgIDs[i].Net3gpp.ToMsgId));
728 } else if( pCBConfig->Net3gppType == TAPI_NETTEXT_CB_MSG_UMTS) {
729 g_variant_builder_add(&b, "{sv}", "CBCategory", g_variant_new_uint16(pCBConfig->MsgIDs[i].Net3gpp2.CBCategory));
730 g_variant_builder_add(&b, "{sv}", "CBLanguage", g_variant_new_uint16(pCBConfig->MsgIDs[i].Net3gpp2.CBLanguage));
732 dbg("Unknown 3gpp type");
735 g_variant_builder_add(&b, "{sv}", "Selected", g_variant_new_byte(pCBConfig->MsgIDs[i].Net3gpp.Selected));
736 g_variant_builder_close(&b);
739 msgId = g_variant_builder_end(&b);
740 packet_msgId = g_variant_new("v", msgId);
742 param = g_variant_new("(iiii@v)", pCBConfig->Net3gppType,
743 pCBConfig->CBEnabled,
744 pCBConfig->MsgIdMaxCount,
745 pCBConfig->MsgIdRangeCount,
748 g_dbus_connection_call(handle->dbus_connection,
749 DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_SMS_INTERFACE,
750 "SetCbConfig", param, NULL,
751 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
752 on_response_default, evt_cb_data);
754 return TAPI_API_SUCCESS;
757 EXPORT_API int tel_set_sms_memory_status(struct tapi_handle *handle, int memoryStatus, tapi_response_cb callback, void* user_data)
759 struct tapi_resp_data *evt_cb_data = NULL;
762 dbg("Func Entrance ");
764 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
766 if ((memoryStatus < TAPI_NETTEXT_PDA_MEMORY_STATUS_AVAILABLE) || (memoryStatus > TAPI_NETTEXT_PDA_MEMORY_STATUS_FULL)) {
767 err("Invalid Input -MemoryStatus Nettext");
768 return TAPI_API_INVALID_INPUT;
771 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
773 param = g_variant_new("(i)", memoryStatus);
775 g_dbus_connection_call(handle->dbus_connection,
776 DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_SMS_INTERFACE,
777 "SetMemStatus", param, NULL,
778 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
779 on_response_default, evt_cb_data);
781 return TAPI_API_SUCCESS;
784 EXPORT_API int tel_send_sms_deliver_report(struct tapi_handle *handle,
785 const TelSmsDatapackageInfo_t *pDataPackage,
786 TelSmsResponse_t RPCause,
787 tapi_response_cb callback, void* user_data)
789 struct tapi_resp_data *evt_cb_data = NULL;
791 GVariant *sca = 0, *packet_sca = 0;
792 GVariant *tpdu = 0, *packet_tpdu = 0;
796 dbg("Func Entrance ");
798 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
799 TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
800 TAPI_RET_ERR_NUM_IF_FAIL(pDataPackage, TAPI_API_INVALID_PTR);
802 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
804 g_variant_builder_init(&b, G_VARIANT_TYPE("ay") );
805 for( i=0; i<TAPI_SIM_SMSP_ADDRESS_LEN; i++) {
806 g_variant_builder_add(&b, "y", pDataPackage->Sca[i] );
808 sca = g_variant_builder_end(&b);
809 packet_sca = g_variant_new("v", sca);
811 g_variant_builder_init(&b, G_VARIANT_TYPE("ay") );
812 for( i=0; i<TAPI_NETTEXT_SMDATA_SIZE_MAX + 1; i++) {
813 g_variant_builder_add(&b, "y", pDataPackage->szData[i] );
815 tpdu = g_variant_builder_end(&b);
816 packet_tpdu = g_variant_new("v", tpdu);
818 param = g_variant_new("(@vi@vi)", packet_sca,
819 pDataPackage->MsgLength,
823 g_dbus_connection_call(handle->dbus_connection,
824 DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_SMS_INTERFACE,
825 "SetDeliveryReport", param, NULL,
826 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
827 on_response_default, evt_cb_data);
829 return TAPI_API_SUCCESS;
832 EXPORT_API int tel_set_sms_message_status(struct tapi_handle *handle, int set_index, TelSmsMsgStatus_t msgStatus, tapi_response_cb callback, void* user_data)
834 struct tapi_resp_data *evt_cb_data = NULL;
837 dbg("Func Entrance ");
839 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
841 if ((set_index < 0) || (set_index > TAPI_NETTEXT_MAX_INDEX) ||
842 (msgStatus > TAPI_NETTEXT_STATUS_RESERVED)) {
843 err("Invalid Input -MsgStatus Set Nettext");
844 return TAPI_API_INVALID_INPUT;
847 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
849 param = g_variant_new("(ii)", set_index, msgStatus);
851 g_dbus_connection_call(handle->dbus_connection,
852 DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_SMS_INTERFACE,
853 "SetMsgStatus", param, NULL,
854 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
855 on_response_default, evt_cb_data);
857 return TAPI_API_SUCCESS;
860 EXPORT_API int tel_get_sms_parameters(struct tapi_handle *handle, int get_index, tapi_response_cb callback, void* user_data)
862 struct tapi_resp_data *evt_cb_data = NULL;
865 dbg("Func Entrance ");
867 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
868 TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
870 if ((get_index < 0) || (get_index > TAPI_NETTEXT_MAX_INDEX)) {
871 err("Invalid Input -SMS Param Get Nettext");
872 return TAPI_API_INVALID_INPUT;
875 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
877 param = g_variant_new("(i)", get_index);
879 g_dbus_connection_call(handle->dbus_connection,
880 DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_SMS_INTERFACE,
881 "GetSmsParams", param, NULL,
882 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
883 on_response_get_sms_params, evt_cb_data);
885 return TAPI_API_SUCCESS;
888 EXPORT_API int tel_set_sms_parameters(struct tapi_handle *handle, const TelSmsParams_t *pSmsSetParameters, tapi_response_cb callback, void* user_data)
890 struct tapi_resp_data *evt_cb_data = NULL;
892 GVariant *alphaId = 0, *packet_alphaId = 0;
893 GVariant *destDialNum = 0, *packet_destDialNum = 0;
894 GVariant *scaDialNum = 0, *packet_scaDialNum = 0;
898 dbg("Func Entrance ");
900 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
901 TAPI_RET_ERR_NUM_IF_FAIL(pSmsSetParameters, TAPI_API_INVALID_PTR);
903 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
905 g_variant_builder_init(&b, G_VARIANT_TYPE("ay") );
906 for( i=0; i<TAPI_SIM_SMSP_ALPHA_ID_LEN_MAX + 1; i++) {
907 g_variant_builder_add(&b, "y", pSmsSetParameters->szAlphaId[i] );
909 alphaId = g_variant_builder_end(&b);
910 packet_alphaId = g_variant_new("v", alphaId);
912 g_variant_builder_init(&b, G_VARIANT_TYPE("ay") );
913 for( i=0; i<TAPI_SIM_SMSP_ADDRESS_LEN + 1; i++) {
914 g_variant_builder_add(&b, "y", pSmsSetParameters->TpDestAddr.szDiallingNum[i] );
916 destDialNum = g_variant_builder_end(&b);
917 packet_destDialNum = g_variant_new("v", destDialNum);
919 g_variant_builder_init(&b, G_VARIANT_TYPE("ay") );
920 for( i=0; i<TAPI_SIM_SMSP_ADDRESS_LEN + 1; i++) {
921 g_variant_builder_add(&b, "y", pSmsSetParameters->TpSvcCntrAddr.szDiallingNum[i] );
923 scaDialNum = g_variant_builder_end(&b);
924 packet_scaDialNum = g_variant_new("v", scaDialNum);
926 param = g_variant_new("(iii@viiii@viii@viii)", pSmsSetParameters->RecordIndex,
927 pSmsSetParameters->RecordLen,
928 pSmsSetParameters->AlphaIdLen,
930 pSmsSetParameters->ParamIndicator,
931 pSmsSetParameters->TpDestAddr.DialNumLen,
932 pSmsSetParameters->TpDestAddr.Ton,
933 pSmsSetParameters->TpDestAddr.Npi,
935 pSmsSetParameters->TpSvcCntrAddr.DialNumLen,
936 pSmsSetParameters->TpSvcCntrAddr.Ton,
937 pSmsSetParameters->TpSvcCntrAddr.Npi,
939 pSmsSetParameters->TpProtocolId,
940 pSmsSetParameters->TpDataCodingScheme,
941 pSmsSetParameters->TpValidityPeriod);
943 g_dbus_connection_call(handle->dbus_connection,
944 DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_SMS_INTERFACE,
945 "SetSmsParams", param, NULL,
946 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
947 on_response_default, evt_cb_data);
949 return TAPI_API_SUCCESS;
952 EXPORT_API int tel_get_sms_parameter_count(struct tapi_handle *handle, tapi_response_cb callback, void* user_data)
954 struct tapi_resp_data *evt_cb_data = NULL;
956 dbg("Func Entrance ");
958 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
959 TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
961 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
963 g_dbus_connection_call(handle->dbus_connection,
964 DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_SMS_INTERFACE,
965 "GetSmsParamCnt", NULL, NULL,
966 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
967 on_response_get_sms_param_cnt, evt_cb_data);
969 return TAPI_API_SUCCESS;
972 EXPORT_API int tel_check_sms_device_status(struct tapi_handle *handle, int *pReadyStatus)
975 GVariant *smsReady = NULL;
977 dbg("Func Entrance ");
979 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
980 TAPI_RET_ERR_NUM_IF_FAIL(pReadyStatus, TAPI_API_INVALID_PTR);
982 memset(pReadyStatus, 0, sizeof(int));
985 smsReady = g_dbus_connection_call_sync(handle->dbus_connection, DBUS_TELEPHONY_SERVICE,
986 handle->path, DBUS_TELEPHONY_SMS_INTERFACE,
987 "GetSmsReadyStatus", NULL, NULL, G_DBUS_CALL_FLAGS_NONE,
988 TAPI_DEFAULT_TIMEOUT, NULL, &error);
990 dbg( "error to get SMS ready_status(%s)", error->message);
991 g_error_free (error);
992 return TAPI_API_OPERATION_FAILED;
995 dbg("get SMS ready_status type_format(%s)", g_variant_get_type_string(smsReady));
997 g_variant_get(smsReady, "(b)", pReadyStatus);
998 g_variant_unref(smsReady);
1000 msg("************SMS_device_status (%d)", *pReadyStatus);
1002 return TAPI_API_SUCCESS;