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.
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);
50 if (evt_cb_data->cb_fn) {
51 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
63 dbg("on_response_default type_format(%s)", g_variant_get_type_string(dbus_result));
65 g_variant_get (dbus_result, "(i)", &result);
68 if (evt_cb_data->cb_fn) {
69 evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
76 static void on_response_read_msg(GObject *source_object, GAsyncResult *res, gpointer user_data)
79 GDBusConnection *conn = NULL;
80 struct tapi_resp_data *evt_cb_data = user_data;
83 TelSmsData_t readMsg = {0,};
84 GVariant *dbus_result = NULL;
86 GVariant *sca = 0, *tpdu = 0;
88 GVariantIter *iter = 0;
89 GVariant *inner_gv = 0;
91 conn = G_DBUS_CONNECTION (source_object);
92 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
97 if (evt_cb_data->cb_fn) {
98 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
110 dbg("on_response_read_msg type_format(%s)", g_variant_get_type_string(dbus_result));
112 // readMsg.SimIndex = 0xFFFFFFFF;
113 g_variant_get (dbus_result, "(iii@vi@v)", &result,
117 &readMsg.SmsData.MsgLength,
120 inner_gv = g_variant_get_variant( sca );
121 g_variant_get(inner_gv, "ay", &iter);
122 while( g_variant_iter_loop(iter, "y", &readMsg.SmsData.Sca[i] ) ) {
124 if( i >= TAPI_SIM_SMSP_ADDRESS_LEN )
128 inner_gv = g_variant_get_variant( tpdu );
129 g_variant_get(inner_gv, "ay", &iter);
131 while( g_variant_iter_loop(iter, "y", &readMsg.SmsData.szData[i]) ) {
133 if( i >= TAPI_NETTEXT_SMDATA_SIZE_MAX + 1 )
136 g_variant_iter_free(iter);
137 g_variant_unref(inner_gv);
140 if (evt_cb_data->cb_fn) {
141 evt_cb_data->cb_fn(evt_cb_data->handle, result, &readMsg, evt_cb_data->user_data);
148 static void on_response_write_msg(GObject *source_object, GAsyncResult *res, gpointer user_data)
150 GError *error = NULL;
151 GDBusConnection *conn = NULL;
152 struct tapi_resp_data *evt_cb_data = user_data;
156 GVariant *dbus_result = NULL;
158 conn = G_DBUS_CONNECTION (source_object);
159 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
164 if (evt_cb_data->cb_fn) {
165 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
177 dbg("on_response_write_msg type_format(%s)", g_variant_get_type_string(dbus_result));
179 g_variant_get (dbus_result, "(ii)", &result, &index);
182 if (evt_cb_data->cb_fn) {
183 evt_cb_data->cb_fn(evt_cb_data->handle, result, &index, evt_cb_data->user_data);
190 static void on_response_delete_msg(GObject *source_object, GAsyncResult *res, gpointer user_data)
192 GError *error = NULL;
193 GDBusConnection *conn = NULL;
194 struct tapi_resp_data *evt_cb_data = user_data;
198 GVariant *dbus_result = NULL;
200 conn = G_DBUS_CONNECTION (source_object);
201 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
206 if (evt_cb_data->cb_fn) {
207 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
219 dbg("on_response_delete_msg type_format(%s)", g_variant_get_type_string(dbus_result));
221 g_variant_get (dbus_result, "(ii)", &result, &index);
224 if (evt_cb_data->cb_fn) {
225 evt_cb_data->cb_fn(evt_cb_data->handle, result, &index, evt_cb_data->user_data);
232 static void on_response_get_msg_count(GObject *source_object, GAsyncResult *res, gpointer user_data)
234 GError *error = NULL;
235 GDBusConnection *conn = NULL;
236 struct tapi_resp_data *evt_cb_data = user_data;
238 TelSmsStoredMsgCountInfo_t storedMsgCnt = {0,};
240 GVariant *dbus_result = NULL;
243 GVariantIter *iter = NULL;
245 conn = G_DBUS_CONNECTION (source_object);
246 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
251 if (evt_cb_data->cb_fn) {
252 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
264 dbg("on_response_get_msg_count type_format(%s)", g_variant_get_type_string(dbus_result));
266 g_variant_get (dbus_result, "(iiiai)", &result,
267 &storedMsgCnt.TotalCount,
268 &storedMsgCnt.UsedCount,
272 while (g_variant_iter_loop(iter, "i", &idx)) {
273 storedMsgCnt.IndexList[i] = idx;
275 if (i >= TAPI_NETTEXT_GSM_SMS_MSG_NUM_MAX)
280 if (evt_cb_data->cb_fn) {
281 evt_cb_data->cb_fn(evt_cb_data->handle, result, &storedMsgCnt, evt_cb_data->user_data);
289 static void on_response_get_sca(GObject *source_object, GAsyncResult *res, gpointer user_data)
291 GError *error = NULL;
292 GDBusConnection *conn = NULL;
293 struct tapi_resp_data *evt_cb_data = user_data;
295 TelSmsAddressInfo_t scaInfo = {0,};
297 GVariant *dbus_result = NULL;
301 GVariantIter *iter = 0;
302 GVariant *inner_gv = 0;
305 conn = G_DBUS_CONNECTION (source_object);
306 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
311 if (evt_cb_data->cb_fn) {
312 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
324 dbg("on_response_get_sca type_format(%s)", g_variant_get_type_string(dbus_result));
326 g_variant_get (dbus_result, "(iiii@v)", &result,
332 inner_gv = g_variant_get_variant( num );
333 g_variant_get(inner_gv, "ay", &iter);
334 while( g_variant_iter_loop(iter, "y", &scaInfo.szDiallingNum[i] ) ) {
336 if( i >= TAPI_SIM_SMSP_ADDRESS_LEN + 1 )
339 g_variant_iter_free(iter);
340 g_variant_unref(inner_gv);
343 if (evt_cb_data->cb_fn) {
344 evt_cb_data->cb_fn(evt_cb_data->handle, result, &scaInfo, evt_cb_data->user_data);
351 static void on_response_get_cb_config(GObject *source_object, GAsyncResult *res, gpointer user_data)
353 GError *error = NULL;
354 GDBusConnection *conn = NULL;
355 struct tapi_resp_data *evt_cb_data = user_data;
358 TelSmsCbConfig_t cbConfig = {0,};
360 GVariant *dbus_result = NULL;
361 GVariant *value = NULL;
362 GVariantIter *iter = NULL;
363 GVariantIter *iter_row = NULL;
364 const gchar *key = NULL;
366 conn = G_DBUS_CONNECTION (source_object);
367 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
372 if (evt_cb_data->cb_fn) {
373 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
385 dbg("on_response_get_cb_config type_format(%s)", g_variant_get_type_string(dbus_result));
387 g_variant_get (dbus_result, "(iiiiiaa{sv})", &result,
388 &cbConfig.Net3gppType,
390 &cbConfig.MsgIdMaxCount,
391 &cbConfig.MsgIdRangeCount,
395 while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
396 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
397 if (!g_strcmp0(key, "FromMsgId")) {
398 cbConfig.MsgIDs[i].Net3gpp.FromMsgId = g_variant_get_uint16(value);
400 if (!g_strcmp0(key, "ToMsgId")) {
401 cbConfig.MsgIDs[i].Net3gpp.ToMsgId = g_variant_get_uint16(value);
403 if (!g_strcmp0(key, "CBCategory")) {
404 cbConfig.MsgIDs[i].Net3gpp2.CBCategory = g_variant_get_uint16(value);
406 if (!g_strcmp0(key, "CBLanguage")) {
407 cbConfig.MsgIDs[i].Net3gpp2.CBLanguage = g_variant_get_uint16(value);
409 if (!g_strcmp0(key, "Selected")) {
410 cbConfig.MsgIDs[i].Net3gpp.Selected = g_variant_get_byte(value);
414 g_variant_iter_free(iter_row);
416 g_variant_iter_free(iter);
419 if (evt_cb_data->cb_fn) {
420 evt_cb_data->cb_fn(evt_cb_data->handle, result, &cbConfig, evt_cb_data->user_data);
427 static void on_response_get_sms_params(GObject *source_object, GAsyncResult *res, gpointer user_data)
429 GError *error = NULL;
430 GDBusConnection *conn = NULL;
431 struct tapi_resp_data *evt_cb_data = user_data;
433 TelSmsParams_t paramInfo = {0,};
435 GVariant *dbus_result = NULL;
437 GVariant *alphaId = 0, *destDialNum = 0, *scaDialNum = 0;
439 GVariantIter *iter = 0;
440 GVariant *inner_gv = 0;
442 conn = G_DBUS_CONNECTION (source_object);
443 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
448 if (evt_cb_data->cb_fn) {
449 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
461 dbg("on_response_get_sms_params type_format(%s)", g_variant_get_type_string(dbus_result));
463 g_variant_get (dbus_result, "(iiii@viiii@viii@viii)", &result,
464 ¶mInfo.RecordIndex,
465 ¶mInfo.RecordLen,
466 ¶mInfo.AlphaIdLen,
468 ¶mInfo.ParamIndicator,
469 ¶mInfo.TpDestAddr.DialNumLen,
470 ¶mInfo.TpDestAddr.Ton,
471 ¶mInfo.TpDestAddr.Npi,
473 ¶mInfo.TpSvcCntrAddr.DialNumLen,
474 ¶mInfo.TpSvcCntrAddr.Ton,
475 ¶mInfo.TpSvcCntrAddr.Npi,
477 ¶mInfo.TpProtocolId,
478 ¶mInfo.TpDataCodingScheme,
479 ¶mInfo.TpValidityPeriod);
481 inner_gv = g_variant_get_variant( alphaId );
482 g_variant_get(inner_gv, "ay", &iter);
483 while( g_variant_iter_loop(iter, "y", ¶mInfo.szAlphaId[i] ) ) {
485 if( i >= TAPI_SIM_SMSP_ALPHA_ID_LEN_MAX + 1 )
489 inner_gv = g_variant_get_variant( destDialNum );
490 g_variant_get(inner_gv, "ay", &iter);
492 while( g_variant_iter_loop(iter, "y", ¶mInfo.TpDestAddr.szDiallingNum[i] ) ) {
494 if( i >= TAPI_SIM_SMSP_ADDRESS_LEN + 1 )
498 inner_gv = g_variant_get_variant( scaDialNum );
499 g_variant_get(inner_gv, "ay", &iter);
501 while( g_variant_iter_loop(iter, "y", ¶mInfo.TpSvcCntrAddr.szDiallingNum[i] ) ) {
503 if( i >= TAPI_SIM_SMSP_ADDRESS_LEN + 1 )
507 g_variant_iter_free(iter);
508 g_variant_unref(inner_gv);
511 if (evt_cb_data->cb_fn) {
512 evt_cb_data->cb_fn(evt_cb_data->handle, result, ¶mInfo, evt_cb_data->user_data);
520 static void on_response_get_sms_param_cnt(GObject *source_object, GAsyncResult *res, gpointer user_data)
522 GError *error = NULL;
523 GDBusConnection *conn = NULL;
524 struct tapi_resp_data *evt_cb_data = user_data;
528 GVariant *dbus_result = NULL;
530 conn = G_DBUS_CONNECTION (source_object);
531 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
536 if (evt_cb_data->cb_fn) {
537 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
549 dbg("on_response_get_sms_param_cnt type_format(%s)", g_variant_get_type_string(dbus_result));
551 g_variant_get (dbus_result, "(ii)", &result,
555 if (evt_cb_data->cb_fn) {
556 evt_cb_data->cb_fn(evt_cb_data->handle, result, &recordCount, evt_cb_data->user_data);
563 EXPORT_API int tel_send_sms(struct tapi_handle *handle,
564 const TelSmsDatapackageInfo_t *pDataPackage,
566 tapi_response_cb callback, void* user_data)
568 struct tapi_resp_data *evt_cb_data = NULL;
570 GVariant *sca = 0, *packet_sca = 0;
571 GVariant *tpdu = 0, *packet_tpdu = 0;
572 GVariantBuilder *b = 0;
574 int emergency_mode = 0;
576 dbg("Func Entrance ");
578 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
579 TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
580 TAPI_RET_ERR_NUM_IF_FAIL(pDataPackage, TAPI_API_INVALID_PTR);
582 if (vconf_get_int("db/telephony/emergency", &emergency_mode) != 0) {
583 err("[FAIL]GET db/telephony/emergency");
584 return TAPI_API_OPERATION_FAILED;
588 if (emergency_mode) {
589 dbg("emergency mode on");
590 return TAPI_API_OPERATION_FAILED;
593 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
595 b = g_variant_builder_new(G_VARIANT_TYPE ("ay"));
596 for( i=0; i<TAPI_SIM_SMSP_ADDRESS_LEN; i++) {
597 g_variant_builder_add( b, "y", pDataPackage->Sca[i] );
599 sca = g_variant_builder_end(b);
600 packet_sca = g_variant_new("v", sca);
602 b = g_variant_builder_new(G_VARIANT_TYPE ("ay"));
603 for( i=0; i<TAPI_NETTEXT_SMDATA_SIZE_MAX + 1; i++) {
604 g_variant_builder_add( b, "y", pDataPackage->szData[i] );
606 tpdu = g_variant_builder_end(b);
607 packet_tpdu = g_variant_new("v", tpdu);
609 param = g_variant_new("(@vi@vi)", packet_sca,
610 pDataPackage->MsgLength,
614 g_dbus_connection_call(handle->dbus_connection,
615 DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_SMS_INTERFACE,
616 "SendMsg", param, NULL,
617 G_DBUS_CALL_FLAGS_NONE, 120000, handle->ca,
618 on_response_default, evt_cb_data);
620 return TAPI_API_SUCCESS;
623 EXPORT_API int tel_read_sms_in_sim(struct tapi_handle *handle, int index, tapi_response_cb callback, void* user_data)
625 struct tapi_resp_data *evt_cb_data = NULL;
628 dbg("Func Entrance ");
630 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
631 TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
633 if( (index < 0) || (index > TAPI_NETTEXT_MAX_INDEX) ) {
634 err("Invalid Input -Read SMS %d",index);
636 return TAPI_API_INVALID_INPUT;
639 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
641 param = g_variant_new("(i)", index);
643 g_dbus_connection_call(handle->dbus_connection,
644 DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_SMS_INTERFACE,
645 "ReadMsg", param, NULL,
646 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
647 on_response_read_msg, evt_cb_data);
649 return TAPI_API_SUCCESS;
652 EXPORT_API int tel_write_sms_in_sim(struct tapi_handle *handle, const TelSmsData_t *pWriteData, tapi_response_cb callback, void* user_data)
654 struct tapi_resp_data *evt_cb_data = NULL;
656 GVariant *sca = 0, *packet_sca = 0;
657 GVariant *tpdu = 0, *packet_tpdu = 0;
658 GVariantBuilder *b = 0;
661 dbg("Func Entrance ");
663 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
664 TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
665 TAPI_RET_ERR_NUM_IF_FAIL(pWriteData, TAPI_API_INVALID_PTR);
667 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
669 b = g_variant_builder_new(G_VARIANT_TYPE ("ay"));
670 for( i=0; i<TAPI_SIM_SMSP_ADDRESS_LEN; i++) {
671 g_variant_builder_add( b, "y", pWriteData->SmsData.Sca[i] );
673 sca = g_variant_builder_end(b);
674 packet_sca = g_variant_new("v", sca);
676 b = g_variant_builder_new(G_VARIANT_TYPE ("ay"));
677 for( i=0; i<TAPI_NETTEXT_SMDATA_SIZE_MAX + 1; i++) {
678 g_variant_builder_add( b, "y", pWriteData->SmsData.szData[i] );
680 tpdu = g_variant_builder_end(b);
681 packet_tpdu = g_variant_new("v", tpdu);
683 param = g_variant_new("(i@vi@v)", pWriteData->MsgStatus,
685 pWriteData->SmsData.MsgLength,
688 g_dbus_connection_call(handle->dbus_connection,
689 DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_SMS_INTERFACE,
690 "SaveMsg", param, NULL,
691 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
692 on_response_write_msg, evt_cb_data);
694 return TAPI_API_SUCCESS;
697 EXPORT_API int tel_delete_sms_in_sim(struct tapi_handle *handle, int index, tapi_response_cb callback, void* user_data)
699 struct tapi_resp_data *evt_cb_data = NULL;
702 dbg("Func Entrance ");
704 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
705 TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
707 if ((index < -1) || (index > TAPI_NETTEXT_MAX_INDEX)) {
708 err("Invalid Index Input");
709 return TAPI_API_INVALID_INPUT;
712 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
714 param = g_variant_new("(i)", index);
716 g_dbus_connection_call(handle->dbus_connection,
717 DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_SMS_INTERFACE,
718 "DeleteMsg", param, NULL,
719 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
720 on_response_delete_msg, evt_cb_data);
722 return TAPI_API_SUCCESS;
725 EXPORT_API int tel_get_sms_count(struct tapi_handle *handle, tapi_response_cb callback, void* user_data)
727 struct tapi_resp_data *evt_cb_data = NULL;
729 dbg("Func Entrance ");
731 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
732 TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
734 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
736 g_dbus_connection_call(handle->dbus_connection,
737 DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_SMS_INTERFACE,
738 "GetMsgCount", NULL, NULL,
739 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
740 on_response_get_msg_count, evt_cb_data);
742 return TAPI_API_SUCCESS;
745 EXPORT_API int tel_get_sms_sca(struct tapi_handle *handle, int index, tapi_response_cb callback, void* user_data)
747 struct tapi_resp_data *evt_cb_data = NULL;
750 dbg("Func Entrance ");
752 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
753 TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
755 if ((index < 0) || (index > TAPI_NETTEXT_MAX_INDEX)) {
756 err("Invalid Index Input");
757 return TAPI_API_INVALID_INPUT;
760 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
762 param = g_variant_new("(i)", index);
764 g_dbus_connection_call(handle->dbus_connection,
765 DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_SMS_INTERFACE,
766 "GetSca", param, NULL,
767 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
768 on_response_get_sca, evt_cb_data);
770 return TAPI_API_SUCCESS;
773 EXPORT_API int tel_set_sms_sca(struct tapi_handle *handle, const TelSmsAddressInfo_t *pSCA, int index, tapi_response_cb callback, void* user_data)
775 struct tapi_resp_data *evt_cb_data = NULL;
777 GVariant *sca = 0, *packet_sca = 0;
778 GVariantBuilder *b = 0;
781 dbg("Func Entrance ");
783 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
784 TAPI_RET_ERR_NUM_IF_FAIL(pSCA, TAPI_API_INVALID_PTR);
786 if ((index < 0) || (index > TAPI_NETTEXT_MAX_INDEX)) {
787 err("Invalid Index Input");
788 return TAPI_API_INVALID_INPUT;
791 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
793 b = g_variant_builder_new(G_VARIANT_TYPE ("ay"));
794 for( i=0; i<TAPI_SIM_SMSP_ADDRESS_LEN + 1; i++) {
795 g_variant_builder_add( b, "y", pSCA->szDiallingNum[i] );
797 sca = g_variant_builder_end(b);
798 packet_sca = g_variant_new("v", sca);
800 param = g_variant_new("(iiii@v)", index,
806 g_dbus_connection_call(handle->dbus_connection,
807 DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_SMS_INTERFACE,
808 "SetSca", param, NULL,
809 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
810 on_response_default, evt_cb_data);
812 return TAPI_API_SUCCESS;
815 EXPORT_API int tel_get_sms_cb_config(struct tapi_handle *handle, tapi_response_cb callback, void* user_data)
817 struct tapi_resp_data *evt_cb_data = NULL;
819 dbg("Func Entrance ");
821 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
822 TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
824 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
826 g_dbus_connection_call(handle->dbus_connection,
827 DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_SMS_INTERFACE,
828 "GetCbConfig", NULL, NULL,
829 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
830 on_response_get_cb_config, evt_cb_data);
832 return TAPI_API_SUCCESS;
835 EXPORT_API int tel_set_sms_cb_config(struct tapi_handle *handle, const TelSmsCbConfig_t *pCBConfig, tapi_response_cb callback, void* user_data)
837 struct tapi_resp_data *evt_cb_data = NULL;
839 GVariant *msgId = 0, *packet_msgId = 0;
843 dbg("Func Entrance ");
845 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
846 TAPI_RET_ERR_NUM_IF_FAIL(pCBConfig, TAPI_API_INVALID_PTR);
848 if ((pCBConfig->Net3gppType > 2) || (pCBConfig->MsgIdRangeCount < 0)) {
849 err("Invalid Input -3gppType(%d)",pCBConfig->Net3gppType);
850 err("Invalid Input -MsgIdRangeCount(%d)",pCBConfig->MsgIdRangeCount);
852 return TAPI_API_INVALID_INPUT;
855 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
857 g_variant_builder_init( &b, G_VARIANT_TYPE("aa{sv}") );
859 for (i = 0; i < pCBConfig->MsgIdRangeCount; i++) {
860 g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
861 if( pCBConfig->Net3gppType == TAPI_NETTEXT_CB_MSG_GSM ) {
862 g_variant_builder_add(&b, "{sv}", "FromMsgId", g_variant_new_uint16(pCBConfig->MsgIDs[i].Net3gpp.FromMsgId));
863 g_variant_builder_add(&b, "{sv}", "ToMsgId", g_variant_new_uint16(pCBConfig->MsgIDs[i].Net3gpp.ToMsgId));
864 } else if( pCBConfig->Net3gppType == TAPI_NETTEXT_CB_MSG_UMTS) {
865 g_variant_builder_add(&b, "{sv}", "CBCategory", g_variant_new_uint16(pCBConfig->MsgIDs[i].Net3gpp2.CBCategory));
866 g_variant_builder_add(&b, "{sv}", "CBLanguage", g_variant_new_uint16(pCBConfig->MsgIDs[i].Net3gpp2.CBLanguage));
868 dbg("Unknown 3gpp type");
871 g_variant_builder_add(&b, "{sv}", "Selected", g_variant_new_byte(pCBConfig->MsgIDs[i].Net3gpp.Selected));
872 g_variant_builder_close(&b);
875 msgId = g_variant_builder_end(&b);
876 packet_msgId = g_variant_new("v", msgId);
878 param = g_variant_new("(iiii@v)", pCBConfig->Net3gppType,
879 pCBConfig->CBEnabled,
880 pCBConfig->MsgIdMaxCount,
881 pCBConfig->MsgIdRangeCount,
884 g_dbus_connection_call(handle->dbus_connection,
885 DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_SMS_INTERFACE,
886 "SetCbConfig", param, NULL,
887 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
888 on_response_default, evt_cb_data);
890 return TAPI_API_SUCCESS;
893 EXPORT_API int tel_set_sms_memory_status(struct tapi_handle *handle, int memoryStatus, tapi_response_cb callback, void* user_data)
895 struct tapi_resp_data *evt_cb_data = NULL;
898 dbg("Func Entrance ");
900 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
902 if ((memoryStatus < TAPI_NETTEXT_PDA_MEMORY_STATUS_AVAILABLE) || (memoryStatus > TAPI_NETTEXT_PDA_MEMORY_STATUS_FULL)) {
903 err("Invalid Input -MemoryStatus Nettext");
904 return TAPI_API_INVALID_INPUT;
907 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
909 param = g_variant_new("(i)", memoryStatus);
911 g_dbus_connection_call(handle->dbus_connection,
912 DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_SMS_INTERFACE,
913 "SetMemStatus", param, NULL,
914 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
915 on_response_default, evt_cb_data);
917 return TAPI_API_SUCCESS;
920 EXPORT_API int tel_get_sms_preferred_bearer(struct tapi_handle *handle, tapi_response_cb callback, void* user_data)
922 struct tapi_resp_data *evt_cb_data = NULL;
924 dbg("Func Entrance ");
926 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
927 TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
929 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
931 g_dbus_connection_call(handle->dbus_connection,
932 DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_SMS_INTERFACE,
933 "GetPrefBearer", NULL, NULL,
934 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
935 on_response_default, evt_cb_data);
937 return TAPI_API_SUCCESS;
940 EXPORT_API int tel_set_sms_preferred_bearer(struct tapi_handle *handle, TelSmsBearerType_t BearerType, tapi_response_cb callback, void* user_data)
942 struct tapi_resp_data *evt_cb_data = NULL;
945 dbg("Func Entrance ");
947 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
949 if ((TAPI_NETTEXT_BEARER_PS_ONLY > BearerType) || (TAPI_NETTEXT_NO_PREFERRED_BEARER < BearerType)) {
950 err("Invalid Input -PrefBearer Set Nettext");
951 return TAPI_API_INVALID_INPUT;
954 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
956 param = g_variant_new("(i)", BearerType);
958 g_dbus_connection_call(handle->dbus_connection,
959 DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_SMS_INTERFACE,
960 "SetPrefBearer", param, NULL,
961 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
962 on_response_default, evt_cb_data);
964 return TAPI_API_SUCCESS;
967 EXPORT_API int tel_send_sms_deliver_report(struct tapi_handle *handle,
968 const TelSmsDatapackageInfo_t *pDataPackage,
969 TelSmsResponse_t RPCause,
970 tapi_response_cb callback, void* user_data)
972 struct tapi_resp_data *evt_cb_data = NULL;
974 GVariant *sca = 0, *packet_sca = 0;
975 GVariant *tpdu = 0, *packet_tpdu = 0;
976 GVariantBuilder *b = 0;
979 dbg("Func Entrance ");
981 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
982 TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
983 TAPI_RET_ERR_NUM_IF_FAIL(pDataPackage, TAPI_API_INVALID_PTR);
985 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
987 b = g_variant_builder_new(G_VARIANT_TYPE ("ay"));
988 for( i=0; i<TAPI_SIM_SMSP_ADDRESS_LEN; i++) {
989 g_variant_builder_add( b, "y", pDataPackage->Sca[i] );
991 sca = g_variant_builder_end(b);
992 packet_sca = g_variant_new("v", sca);
994 b = g_variant_builder_new(G_VARIANT_TYPE ("ay"));
995 for( i=0; i<TAPI_NETTEXT_SMDATA_SIZE_MAX + 1; i++) {
996 g_variant_builder_add( b, "y", pDataPackage->szData[i] );
998 tpdu = g_variant_builder_end(b);
999 packet_tpdu = g_variant_new("v", tpdu);
1001 param = g_variant_new("(@vi@vi)", packet_sca,
1002 pDataPackage->MsgLength,
1006 g_dbus_connection_call(handle->dbus_connection,
1007 DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_SMS_INTERFACE,
1008 "SetDeliveryReport", param, NULL,
1009 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1010 on_response_default, evt_cb_data);
1012 return TAPI_API_SUCCESS;
1015 EXPORT_API int tel_set_sms_message_status(struct tapi_handle *handle, int index, TelSmsMsgStatus_t msgStatus, tapi_response_cb callback, void* user_data)
1017 struct tapi_resp_data *evt_cb_data = NULL;
1020 dbg("Func Entrance ");
1022 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1024 if ((index < 0) || (index > TAPI_NETTEXT_MAX_INDEX) ||
1025 (msgStatus > TAPI_NETTEXT_STATUS_RESERVED)) {
1026 err("Invalid Input -MsgStatus Set Nettext");
1027 return TAPI_API_INVALID_INPUT;
1030 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1032 param = g_variant_new("(ii)", index, msgStatus);
1034 g_dbus_connection_call(handle->dbus_connection,
1035 DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_SMS_INTERFACE,
1036 "SetMsgStatus", param, NULL,
1037 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1038 on_response_default, evt_cb_data);
1040 return TAPI_API_SUCCESS;
1043 EXPORT_API int tel_get_sms_parameters(struct tapi_handle *handle, int index, tapi_response_cb callback, void* user_data)
1045 struct tapi_resp_data *evt_cb_data = NULL;
1048 dbg("Func Entrance ");
1050 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1051 TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
1053 if ((index < 0) || (index > TAPI_NETTEXT_MAX_INDEX)) {
1054 err("Invalid Input -SMS Param Get Nettext");
1055 return TAPI_API_INVALID_INPUT;
1058 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1060 param = g_variant_new("(i)", index);
1062 g_dbus_connection_call(handle->dbus_connection,
1063 DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_SMS_INTERFACE,
1064 "GetSmsParams", param, NULL,
1065 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1066 on_response_get_sms_params, evt_cb_data);
1068 return TAPI_API_SUCCESS;
1071 EXPORT_API int tel_set_sms_parameters(struct tapi_handle *handle, const TelSmsParams_t *pSmsSetParameters, tapi_response_cb callback, void* user_data)
1073 struct tapi_resp_data *evt_cb_data = NULL;
1075 GVariant *alphaId = 0, *packet_alphaId = 0;
1076 GVariant *destDialNum = 0, *packet_destDialNum = 0;
1077 GVariant *scaDialNum = 0, *packet_scaDialNum = 0;
1078 GVariantBuilder *b = 0;
1081 dbg("Func Entrance ");
1083 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1084 TAPI_RET_ERR_NUM_IF_FAIL(pSmsSetParameters, TAPI_API_INVALID_PTR);
1086 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1088 b = g_variant_builder_new(G_VARIANT_TYPE ("ay"));
1089 for( i=0; i<TAPI_SIM_SMSP_ALPHA_ID_LEN_MAX + 1; i++) {
1090 g_variant_builder_add( b, "y", pSmsSetParameters->szAlphaId[i] );
1092 alphaId = g_variant_builder_end(b);
1093 packet_alphaId = g_variant_new("v", alphaId);
1095 b = g_variant_builder_new(G_VARIANT_TYPE ("ay"));
1096 for( i=0; i<TAPI_SIM_SMSP_ADDRESS_LEN + 1; i++) {
1097 g_variant_builder_add( b, "y", pSmsSetParameters->TpDestAddr.szDiallingNum[i] );
1099 destDialNum = g_variant_builder_end(b);
1100 packet_destDialNum = g_variant_new("v", destDialNum);
1102 b = g_variant_builder_new(G_VARIANT_TYPE ("ay"));
1103 for( i=0; i<TAPI_SIM_SMSP_ADDRESS_LEN + 1; i++) {
1104 g_variant_builder_add( b, "y", pSmsSetParameters->TpSvcCntrAddr.szDiallingNum[i] );
1106 scaDialNum = g_variant_builder_end(b);
1107 packet_scaDialNum = g_variant_new("v", scaDialNum);
1109 param = g_variant_new("(iii@viiii@viii@viii)", pSmsSetParameters->RecordIndex,
1110 pSmsSetParameters->RecordLen,
1111 pSmsSetParameters->AlphaIdLen,
1113 pSmsSetParameters->ParamIndicator,
1114 pSmsSetParameters->TpDestAddr.DialNumLen,
1115 pSmsSetParameters->TpDestAddr.Ton,
1116 pSmsSetParameters->TpDestAddr.Npi,
1118 pSmsSetParameters->TpSvcCntrAddr.DialNumLen,
1119 pSmsSetParameters->TpSvcCntrAddr.Ton,
1120 pSmsSetParameters->TpSvcCntrAddr.Npi,
1122 pSmsSetParameters->TpProtocolId,
1123 pSmsSetParameters->TpDataCodingScheme,
1124 pSmsSetParameters->TpValidityPeriod);
1126 g_dbus_connection_call(handle->dbus_connection,
1127 DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_SMS_INTERFACE,
1128 "SetSmsParams", param, NULL,
1129 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1130 on_response_default, evt_cb_data);
1132 return TAPI_API_SUCCESS;
1135 EXPORT_API int tel_get_sms_parameter_count(struct tapi_handle *handle, tapi_response_cb callback, void* user_data)
1137 struct tapi_resp_data *evt_cb_data = NULL;
1139 dbg("Func Entrance ");
1141 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1142 TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
1144 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1146 g_dbus_connection_call(handle->dbus_connection,
1147 DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_SMS_INTERFACE,
1148 "GetSmsParamCnt", NULL, NULL,
1149 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1150 on_response_get_sms_param_cnt, evt_cb_data);
1152 return TAPI_API_SUCCESS;
1158 * This API is used to send an SMS message to the network. This API allows keeping
1159 * the dedicated link at lower layers by passing information as more messages to send in parameters.
1160 * This will enable not to release if a dedicated connection is used for transmission.
1162 * @return TRUE in case of success and FALSE in case of error .
1163 * @param[in] TelSmsMsgInfo_t - SMS_SUBMIT/ACK/CANCEL and its length have to be passed in this structure.
1165 * unsigned int MoreMsgToSend will be set to TRUE when there are more than one message to be
1166 * send or Multiple segmented concatenated message to be send, otherwise FALSE. This flag
1167 * indicates OEM that more messages to send.
1169 * @param[out] RequestId-Unique identifier for a particular request
1170 * Its value can be any value from 0 to 255 if the API is returned successfully
1171 * -1 (INVALID_REQUEST_ID) will be sent in case of failure
1173 * @Interface Asynchronous.
1175 * @Refer TelSmsMsgInfo_t.
1177 EXPORT_API int tel_send_sms_msg(struct tapi_handle *handle, const TelSmsMsgInfo_t *pSmsMsgInfo, unsigned int MoreMsgToSend, tapi_response_cb callback, void* user_data)
1179 struct tapi_resp_data *evt_cb_data = NULL;
1182 dbg("Func Entrance ");
1184 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1185 TS_BOOL ret = FALSE;
1186 int api_err = TAPI_API_SUCCESS;
1187 int emergency_mode = 0;
1189 if (vconf_get_int("db/telephony/emergency", &emergency_mode) != 0) {
1190 TAPI_LIB_DEBUG(LEVEL_ERR, "[FAIL]GET db/telephony/emergency");
1191 return TAPI_API_OPERATION_FAILED;
1193 if (emergency_mode) {
1194 TAPI_LIB_DEBUG(LEVEL_DEBUG, "emergency mode on");
1195 return TAPI_API_OPERATION_FAILED;
1198 TAPI_RET_ERR_NUM_IF_FAIL(pSmsMsgInfo ,TAPI_API_INVALID_PTR);
1200 if (conn_name.length_of_name == 0) {
1201 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
1202 return TAPI_API_OPERATION_FAILED;
1205 TAPI_RET_ERR_NUM_IF_FAIL(tapi_check_dbus_status(), TAPI_API_SYSTEM_RPC_LINK_NOT_EST);
1206 TAPI_GLIB_INIT_PARAMS();
1208 TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,
1209 out_param1,out_param2,out_param3,out_param4);
1211 g_array_append_vals(in_param1, pSmsMsgInfo, sizeof(TelSmsMsgInfo_t));
1212 g_array_append_vals(in_param2, &MoreMsgToSend, sizeof(unsigned int));
1213 g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
1215 ret = tapi_send_request(TAPI_CS_SERVICE_NETTEXT, TAPI_CS_NETTEXT_SEND_EX, in_param1, in_param2, in_param3,
1216 in_param4, &out_param1, &out_param2, &out_param3, &out_param4);
1219 api_err = g_array_index(out_param1, int, 0);
1222 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
1225 TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,
1226 out_param1,out_param2,out_param3,out_param4);
1232 EXPORT_API int tel_check_sms_device_status(struct tapi_handle *handle, int *pReadyStatus)
1235 GVariant *smsReady = NULL;
1237 dbg("Func Entrance ");
1239 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1240 TAPI_RET_ERR_NUM_IF_FAIL(pReadyStatus, TAPI_API_INVALID_PTR);
1242 memset(pReadyStatus, 0, sizeof(int));
1245 smsReady = g_dbus_connection_call_sync(handle->dbus_connection, DBUS_TELEPHONY_SERVICE , handle->path,
1246 DBUS_TELEPHONY_SMS_INTERFACE, "GetSmsReadyStatus", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, NULL, &error);
1249 dbg( "error to get SMS ready_status(%s)", error->message);
1250 g_error_free (error);
1251 return TAPI_API_OPERATION_FAILED;
1254 dbg("get SMS ready_status type_format(%s)", g_variant_get_type_string(smsReady));
1256 g_variant_get(smsReady, "(b)", pReadyStatus);
1258 dbg("************SMS_device_status (%d)", *pReadyStatus);
1260 return TAPI_API_SUCCESS;
1266 * This function enables to application to set that the device is ready to recieve messages from network.
1268 * @return Returns appropriate error code. Refer TapiResult_t .
1272 * @Interface Synchronous.
1276 EXPORT_API int tel_set_sms_device_status(struct tapi_handle *handle)
1278 struct tapi_resp_data *evt_cb_data = NULL;
1281 dbg("Func Entrance ");
1283 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1285 TS_BOOL ret = FALSE;
1286 int api_err = TAPI_API_SUCCESS;
1288 TAPI_RET_ERR_NUM_IF_FAIL(tapi_check_dbus_status_internal(), TAPI_API_SYSTEM_RPC_LINK_NOT_EST);
1289 TAPI_GLIB_INIT_PARAMS();
1290 TAPI_GLIB_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param1, out_param2, out_param3, out_param4);
1292 ret = tapi_send_request_internal(TAPI_CS_SERVICE_NETTEXT, TAPI_CS_NETTEXT_DEVICEREADY,
1293 in_param1, in_param2, in_param3, in_param4,
1294 &out_param1, &out_param2, &out_param3, &out_param4);
1297 api_err = g_array_index(out_param1, int, 0);
1300 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
1303 TAPI_GLIB_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param1, out_param2, out_param3, out_param4);