src/tapi_sms.c

   1 /*
   2  * libslp-tapi
   3  *
   4  * Copyright (c) 2014 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 "tapi_common.h"
  26 #include "TapiUtility.h"
  27 #include "TelSms.h"
  28
  29 #include "common.h"
  30 #include "tapi_log.h"
  31 #include "ITapiNetText.h"
  32
  33 static void on_response_default(GObject *source_object, GAsyncResult *res, gpointer user_data)
  34 {
  35         GError *error = NULL;
  36         GDBusConnection *conn = NULL;
  37         struct tapi_resp_data *evt_cb_data = user_data;
  38         int result = -1;
  39
  40         GVariant *dbus_result = NULL;
  41         int data = 0;
  42
  43         conn = G_DBUS_CONNECTION (source_object);
  44         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
  45         CHECK_ERROR(error);
  46
  47         dbg("on_response_default type_format(%s)", g_variant_get_type_string(dbus_result));
  48
  49         g_variant_get (dbus_result, "(i)", &result);
  50
  51         if (evt_cb_data) {
  52                 if (evt_cb_data->cb_fn) {
  53                         evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
  54                 }
  55
  56                 g_free(evt_cb_data);
  57         }
  58         g_variant_unref(dbus_result);
  59 }
  60
  61 static void on_response_read_msg(GObject *source_object, GAsyncResult *res, gpointer user_data)
  62 {
  63         GError *error = NULL;
  64         GDBusConnection *conn = NULL;
  65         struct tapi_resp_data *evt_cb_data = user_data;
  66         int result = -1;
  67
  68         TelSmsData_t    readMsg = {0,};
  69         GVariant *dbus_result = NULL;
  70
  71         GVariant *sca = 0, *tpdu = 0;
  72         int i = 0;
  73         GVariantIter *iter = 0;
  74         GVariant *inner_gv = 0;
  75
  76         conn = G_DBUS_CONNECTION (source_object);
  77         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
  78         CHECK_ERROR(error);
  79
  80         dbg("on_response_read_msg type_format(%s)", g_variant_get_type_string(dbus_result));
  81
  82 //      readMsg.SimIndex = 0xFFFFFFFF;
  83         g_variant_get (dbus_result, "(iii@vi@v)", &result,
  84                         &readMsg.SimIndex,
  85                         &readMsg.MsgStatus,
  86                         &sca,
  87                         &readMsg.SmsData.MsgLength,
  88                         &tpdu);
  89
  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] ) ) {
  93                 i++;
  94                 if( i >= TAPI_SIM_SMSP_ADDRESS_LEN )
  95                         break;
  96         }
  97
  98         inner_gv = g_variant_get_variant( tpdu );
  99         g_variant_get(inner_gv, "ay", &iter);
 100         i= 0;
 101         while( g_variant_iter_loop(iter, "y", &readMsg.SmsData.szData[i]) ) {
 102                 i++;
 103                 if( i >= TAPI_NETTEXT_SMDATA_SIZE_MAX + 1 )
 104                         break;
 105         }
 106         g_variant_iter_free(iter);
 107         g_variant_unref(inner_gv);
 108
 109         if (evt_cb_data) {
 110                 if (evt_cb_data->cb_fn) {
 111                         evt_cb_data->cb_fn(evt_cb_data->handle, result, &readMsg, evt_cb_data->user_data);
 112                 }
 113
 114                 g_free(evt_cb_data);
 115         }
 116         g_variant_unref(dbus_result);
 117 }
 118
 119 static void on_response_write_msg(GObject *source_object, GAsyncResult *res, gpointer user_data)
 120 {
 121         GError *error = NULL;
 122         GDBusConnection *conn = NULL;
 123         struct tapi_resp_data *evt_cb_data = user_data;
 124         int result = -1;
 125         int sms_index = 0;
 126
 127         GVariant *dbus_result = NULL;
 128
 129         conn = G_DBUS_CONNECTION (source_object);
 130         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 131         CHECK_ERROR(error);
 132
 133         dbg("on_response_write_msg type_format(%s)", g_variant_get_type_string(dbus_result));
 134
 135         g_variant_get (dbus_result, "(ii)", &result, &sms_index);
 136
 137         if (evt_cb_data) {
 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);
 140                 }
 141
 142                 g_free(evt_cb_data);
 143         }
 144         g_variant_unref(dbus_result);
 145 }
 146
 147 static void on_response_delete_msg(GObject *source_object, GAsyncResult *res, gpointer user_data)
 148 {
 149         GError *error = NULL;
 150         GDBusConnection *conn = NULL;
 151         struct tapi_resp_data *evt_cb_data = user_data;
 152         int result = -1;
 153         int del_index = -1;
 154
 155         GVariant *dbus_result = NULL;
 156
 157         conn = G_DBUS_CONNECTION (source_object);
 158         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 159         CHECK_ERROR(error);
 160
 161         dbg("on_response_delete_msg type_format(%s)", g_variant_get_type_string(dbus_result));
 162
 163         g_variant_get (dbus_result, "(ii)", &result, &del_index);
 164
 165         if (evt_cb_data) {
 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);
 168                 }
 169
 170                 g_free(evt_cb_data);
 171         }
 172         g_variant_unref(dbus_result);
 173 }
 174
 175 static void on_response_get_msg_count(GObject *source_object, GAsyncResult *res, gpointer user_data)
 176 {
 177         GError *error = NULL;
 178         GDBusConnection *conn = NULL;
 179         struct tapi_resp_data *evt_cb_data = user_data;
 180         int result = -1;
 181         TelSmsStoredMsgCountInfo_t storedMsgCnt = {0,};
 182
 183         GVariant *dbus_result = NULL;
 184         int i = 0;
 185         int idx = 0;
 186         GVariantIter *iter = NULL;
 187
 188         conn = G_DBUS_CONNECTION (source_object);
 189         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 190         CHECK_ERROR(error);
 191
 192         dbg("on_response_get_msg_count type_format(%s)", g_variant_get_type_string(dbus_result));
 193
 194         g_variant_get (dbus_result, "(iiiai)", &result,
 195                                                                 &storedMsgCnt.TotalCount,
 196                                                                 &storedMsgCnt.UsedCount,
 197                                                                 &iter);
 198
 199         i = 0;
 200         while (g_variant_iter_loop(iter, "i", &idx)) {
 201                 storedMsgCnt.IndexList[i] = idx;
 202                 i++;
 203                 if (i >= TAPI_NETTEXT_SMS_MSG_NUM_MAX)
 204                         break;
 205         }
 206
 207         if (evt_cb_data) {
 208                 if (evt_cb_data->cb_fn) {
 209                         evt_cb_data->cb_fn(evt_cb_data->handle, result, &storedMsgCnt, evt_cb_data->user_data);
 210                 }
 211
 212                 g_free(evt_cb_data);
 213         }
 214         g_variant_unref(dbus_result);
 215 }
 216
 217 static void on_response_get_sca(GObject *source_object, GAsyncResult *res, gpointer user_data)
 218 {
 219         GError *error = NULL;
 220         GDBusConnection *conn = NULL;
 221         struct tapi_resp_data *evt_cb_data = user_data;
 222         int result = -1;
 223         TelSmsAddressInfo_t scaInfo = {0,};
 224
 225         GVariant *dbus_result = NULL;
 226
 227         GVariant *num = 0;
 228         int i = 0;
 229         GVariantIter *iter = 0;
 230         GVariant *inner_gv = 0;
 231
 232
 233         conn = G_DBUS_CONNECTION (source_object);
 234         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 235         CHECK_ERROR(error);
 236
 237         dbg("on_response_get_sca type_format(%s)", g_variant_get_type_string(dbus_result));
 238
 239         g_variant_get (dbus_result, "(iiii@v)", &result,
 240                                         &scaInfo.Ton,
 241                                         &scaInfo.Npi,
 242                                         &scaInfo.DialNumLen,
 243                                         &num);
 244
 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] ) ) {
 248                 i++;
 249                 if( i >= TAPI_SIM_SMSP_ADDRESS_LEN + 1 )
 250                         break;
 251         }
 252         g_variant_iter_free(iter);
 253         g_variant_unref(inner_gv);
 254
 255         if (evt_cb_data) {
 256                 if (evt_cb_data->cb_fn) {
 257                         evt_cb_data->cb_fn(evt_cb_data->handle, result, &scaInfo, evt_cb_data->user_data);
 258                 }
 259
 260                 g_free(evt_cb_data);
 261         }
 262         g_variant_unref(dbus_result);
 263 }
 264
 265 static void on_response_get_cb_config(GObject *source_object, GAsyncResult *res, gpointer user_data)
 266 {
 267         GError *error = NULL;
 268         GDBusConnection *conn = NULL;
 269         struct tapi_resp_data *evt_cb_data = user_data;
 270         int result = -1;
 271         int i;
 272         TelSmsCbConfig_t cbConfig = {0,};
 273
 274         GVariant *dbus_result = NULL;
 275         GVariant *value = NULL;
 276         GVariantIter *iter = NULL;
 277         GVariantIter *iter_row = NULL;
 278         const gchar *key = NULL;
 279
 280         conn = G_DBUS_CONNECTION (source_object);
 281         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 282         CHECK_ERROR(error);
 283
 284         dbg("on_response_get_cb_config type_format(%s)", g_variant_get_type_string(dbus_result));
 285
 286         g_variant_get (dbus_result, "(iiiiiaa{sv})", &result,
 287                                         &cbConfig.Net3gppType,
 288                                         &cbConfig.CBEnabled,
 289                                         &cbConfig.MsgIdMaxCount,
 290                                         &cbConfig.MsgIdRangeCount,
 291                                         &iter);
 292
 293         i = 0;
 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);
 298                         }
 299                         if (!g_strcmp0(key, "ToMsgId")) {
 300                                 cbConfig.MsgIDs[i].Net3gpp.ToMsgId = g_variant_get_uint16(value);
 301                         }
 302                         if (!g_strcmp0(key, "CBCategory")) {
 303                                 cbConfig.MsgIDs[i].Net3gpp2.CBCategory = g_variant_get_uint16(value);
 304                         }
 305                         if (!g_strcmp0(key, "CBLanguage")) {
 306                                 cbConfig.MsgIDs[i].Net3gpp2.CBLanguage = g_variant_get_uint16(value);
 307                         }
 308                         if (!g_strcmp0(key, "Selected")) {
 309                                 cbConfig.MsgIDs[i].Net3gpp.Selected = g_variant_get_byte(value);
 310                         }
 311                 }
 312                 i++;
 313                 g_variant_iter_free(iter_row);
 314         }
 315         g_variant_iter_free(iter);
 316
 317         if (evt_cb_data) {
 318                 if (evt_cb_data->cb_fn) {
 319                         evt_cb_data->cb_fn(evt_cb_data->handle, result, &cbConfig, evt_cb_data->user_data);
 320                 }
 321
 322                 g_free(evt_cb_data);
 323         }
 324         g_variant_unref(dbus_result);
 325 }
 326
 327 static void on_response_get_sms_params(GObject *source_object, GAsyncResult *res, gpointer user_data)
 328 {
 329         GError *error = NULL;
 330         GDBusConnection *conn = NULL;
 331         struct tapi_resp_data *evt_cb_data = user_data;
 332         int result = -1;
 333         TelSmsParams_t paramInfo = {0,};
 334
 335         GVariant *dbus_result = NULL;
 336
 337         GVariant *alphaId = 0, *destDialNum = 0, *scaDialNum = 0;
 338         int i = 0;
 339         GVariantIter *iter = 0;
 340         GVariant *inner_gv = 0;
 341
 342         conn = G_DBUS_CONNECTION (source_object);
 343         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 344         CHECK_ERROR(error);
 345
 346         dbg("on_response_get_sms_params type_format(%s)", g_variant_get_type_string(dbus_result));
 347
 348         g_variant_get (dbus_result, "(iiii@viiii@viii@viii)", &result,
 349                                                                 &paramInfo.RecordIndex,
 350                                                                 &paramInfo.RecordLen,
 351                                                                 &paramInfo.AlphaIdLen,
 352                                                                 &alphaId,
 353                                                                 &paramInfo.ParamIndicator,
 354                                                                 &paramInfo.TpDestAddr.DialNumLen,
 355                                                                 &paramInfo.TpDestAddr.Ton,
 356                                                                 &paramInfo.TpDestAddr.Npi,
 357                                                                 &destDialNum,
 358                                                                 &paramInfo.TpSvcCntrAddr.DialNumLen,
 359                                                                 &paramInfo.TpSvcCntrAddr.Ton,
 360                                                                 &paramInfo.TpSvcCntrAddr.Npi,
 361                                                                 &scaDialNum,
 362                                                                 &paramInfo.TpProtocolId,
 363                                                                 &paramInfo.TpDataCodingScheme,
 364                                                                 &paramInfo.TpValidityPeriod);
 365
 366         inner_gv = g_variant_get_variant( alphaId );
 367         g_variant_get(inner_gv, "ay", &iter);
 368         while( g_variant_iter_loop(iter, "y", &paramInfo.szAlphaId[i] ) ) {
 369                 i++;
 370                 if( i >= TAPI_SIM_SMSP_ALPHA_ID_LEN_MAX + 1 )
 371                         break;
 372         }
 373
 374         inner_gv = g_variant_get_variant( destDialNum );
 375         g_variant_get(inner_gv, "ay", &iter);
 376         i = 0;
 377         while( g_variant_iter_loop(iter, "y", &paramInfo.TpDestAddr.szDiallingNum[i] ) ) {
 378                 i++;
 379                 if( i >= TAPI_SIM_SMSP_ADDRESS_LEN + 1 )
 380                         break;
 381         }
 382
 383         inner_gv = g_variant_get_variant( scaDialNum );
 384         g_variant_get(inner_gv, "ay", &iter);
 385         i = 0;
 386         while( g_variant_iter_loop(iter, "y", &paramInfo.TpSvcCntrAddr.szDiallingNum[i] ) ) {
 387                 i++;
 388                 if( i >= TAPI_SIM_SMSP_ADDRESS_LEN + 1 )
 389                         break;
 390         }
 391
 392         g_variant_iter_free(iter);
 393         g_variant_unref(inner_gv);
 394
 395         if (evt_cb_data) {
 396                 if (evt_cb_data->cb_fn) {
 397                         evt_cb_data->cb_fn(evt_cb_data->handle, result, &paramInfo, evt_cb_data->user_data);
 398                 }
 399
 400                 g_free(evt_cb_data);
 401         }
 402         g_variant_unref(dbus_result);
 403 }
 404
 405 static void on_response_get_sms_param_cnt(GObject *source_object, GAsyncResult *res, gpointer user_data)
 406 {
 407         GError *error = NULL;
 408         GDBusConnection *conn = NULL;
 409         struct tapi_resp_data *evt_cb_data = user_data;
 410         int result = -1;
 411         int recordCount = 0;
 412
 413         GVariant *dbus_result = NULL;
 414
 415         conn = G_DBUS_CONNECTION (source_object);
 416         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 417         CHECK_ERROR(error);
 418
 419         dbg("on_response_get_sms_param_cnt type_format(%s)", g_variant_get_type_string(dbus_result));
 420
 421         g_variant_get (dbus_result, "(ii)", &result,
 422                         &recordCount);
 423
 424         if (evt_cb_data) {
 425                 if (evt_cb_data->cb_fn) {
 426                         evt_cb_data->cb_fn(evt_cb_data->handle, result, &recordCount, evt_cb_data->user_data);
 427                 }
 428
 429                 g_free(evt_cb_data);
 430         }
 431         g_variant_unref(dbus_result);
 432 }
 433
 434 EXPORT_API int tel_send_sms(struct tapi_handle *handle,
 435                 const TelSmsDatapackageInfo_t *pDataPackage,
 436                 int bMoreMsgToSend,
 437                 tapi_response_cb callback, void* user_data)
 438 {
 439         struct tapi_resp_data *evt_cb_data = NULL;
 440         GVariant *param;
 441         GVariant *sca = 0, *packet_sca = 0;
 442         GVariant *tpdu = 0, *packet_tpdu = 0;
 443         GVariantBuilder b;
 444         int i;
 445
 446         dbg("Func Entrance ");
 447
 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);
 451
 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;
 455         }
 456
 457         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 458
 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] );
 462         }
 463         sca = g_variant_builder_end(&b);
 464         packet_sca = g_variant_new("v", sca);
 465
 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] );
 469         }
 470         tpdu = g_variant_builder_end(&b);
 471         packet_tpdu = g_variant_new("v", tpdu);
 472
 473         param = g_variant_new("(@vi@vi)", packet_sca,
 474                                                         pDataPackage->MsgLength,
 475                                                         packet_tpdu,
 476                                                         bMoreMsgToSend);
 477
 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);
 483
 484         return TAPI_API_SUCCESS;
 485 }
 486
 487 EXPORT_API int tel_read_sms_in_sim(struct tapi_handle *handle, int read_index, tapi_response_cb callback, void* user_data)
 488 {
 489         struct tapi_resp_data *evt_cb_data = NULL;
 490         GVariant *param;
 491
 492         dbg("Func Entrance ");
 493
 494         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 495         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
 496
 497         if( (read_index < 0) || (read_index > TAPI_NETTEXT_MAX_INDEX) ) {
 498                 err("Invalid Input -Read SMS %d",read_index);
 499
 500                 return TAPI_API_INVALID_INPUT;
 501         }
 502
 503         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 504
 505         param = g_variant_new("(i)", read_index);
 506
 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);
 512
 513         return TAPI_API_SUCCESS;
 514 }
 515
 516 EXPORT_API int tel_write_sms_in_sim(struct tapi_handle *handle, const TelSmsData_t *pWriteData, tapi_response_cb callback, void* user_data)
 517 {
 518         struct tapi_resp_data *evt_cb_data = NULL;
 519         GVariant *param;
 520         GVariant *sca = 0, *packet_sca = 0;
 521         GVariant *tpdu = 0, *packet_tpdu = 0;
 522         GVariantBuilder b;
 523         int i;
 524
 525         dbg("Func Entrance ");
 526
 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);
 530
 531         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 532
 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] );
 536         }
 537         sca = g_variant_builder_end(&b);
 538         packet_sca = g_variant_new("v", sca);
 539
 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] );
 543         }
 544         tpdu = g_variant_builder_end(&b);
 545         packet_tpdu = g_variant_new("v", tpdu);
 546
 547         param = g_variant_new("(i@vi@v)", pWriteData->MsgStatus,
 548                                                         packet_sca,
 549                                                         pWriteData->SmsData.MsgLength,
 550                                                         packet_tpdu);
 551
 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);
 557
 558         return TAPI_API_SUCCESS;
 559 }
 560
 561 EXPORT_API int tel_delete_sms_in_sim(struct tapi_handle *handle, int del_index, tapi_response_cb callback, void* user_data)
 562 {
 563         struct tapi_resp_data *evt_cb_data = NULL;
 564         GVariant *param;
 565
 566         dbg("Func Entrance ");
 567
 568         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 569         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
 570
 571         if ((del_index < -1) || (del_index > TAPI_NETTEXT_MAX_INDEX)) {
 572                 err("Invalid Index Input");
 573                 return TAPI_API_INVALID_INPUT;
 574         }
 575
 576         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 577
 578         param = g_variant_new("(i)", del_index);
 579
 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);
 585
 586         return TAPI_API_SUCCESS;
 587 }
 588
 589 EXPORT_API int tel_get_sms_count(struct tapi_handle *handle, tapi_response_cb callback, void* user_data)
 590 {
 591         struct tapi_resp_data *evt_cb_data = NULL;
 592
 593         dbg("Func Entrance ");
 594
 595         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 596         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
 597
 598         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 599
 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);
 605
 606         return TAPI_API_SUCCESS;
 607 }
 608
 609 EXPORT_API int tel_get_sms_sca(struct tapi_handle *handle, int sca_index, tapi_response_cb callback, void* user_data)
 610 {
 611         struct tapi_resp_data *evt_cb_data = NULL;
 612         GVariant *param;
 613
 614         dbg("Func Entrance ");
 615
 616         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 617         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
 618
 619         if ((sca_index < 0) || (sca_index > TAPI_NETTEXT_MAX_INDEX)) {
 620                 err("Invalid Index Input");
 621                 return TAPI_API_INVALID_INPUT;
 622         }
 623
 624         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 625
 626         param = g_variant_new("(i)", sca_index);
 627
 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);
 633
 634         return TAPI_API_SUCCESS;
 635 }
 636
 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)
 638 {
 639         struct tapi_resp_data *evt_cb_data = NULL;
 640         GVariant *param;
 641         GVariant *sca = 0, *packet_sca = 0;
 642         GVariantBuilder b;
 643         int i;
 644
 645         dbg("Func Entrance ");
 646
 647         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 648         TAPI_RET_ERR_NUM_IF_FAIL(pSCA, TAPI_API_INVALID_PTR);
 649
 650         if ((sca_index < 0) || (sca_index > TAPI_NETTEXT_MAX_INDEX)) {
 651                 err("Invalid Index Input");
 652                 return TAPI_API_INVALID_INPUT;
 653         }
 654
 655         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 656
 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] );
 660         }
 661         sca = g_variant_builder_end(&b);
 662         packet_sca = g_variant_new("v", sca);
 663
 664         param = g_variant_new("(iiii@v)", sca_index,
 665                                                         pSCA->Ton,
 666                                                         pSCA->Npi,
 667                                                         pSCA->DialNumLen,
 668                                                         packet_sca);
 669
 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);
 675
 676         return TAPI_API_SUCCESS;
 677 }
 678
 679 EXPORT_API int tel_get_sms_cb_config(struct tapi_handle *handle, tapi_response_cb callback, void* user_data)
 680 {
 681         struct tapi_resp_data *evt_cb_data = NULL;
 682
 683         dbg("Func Entrance ");
 684
 685         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 686         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
 687
 688         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 689
 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);
 695
 696         return TAPI_API_SUCCESS;
 697 }
 698
 699 EXPORT_API int tel_set_sms_cb_config(struct tapi_handle *handle, const TelSmsCbConfig_t *pCBConfig, tapi_response_cb callback, void* user_data)
 700 {
 701         struct tapi_resp_data *evt_cb_data = NULL;
 702         GVariant *param;
 703         GVariant *msgId = 0, *packet_msgId = 0;
 704         GVariantBuilder b;
 705         int i = 0;
 706
 707         dbg("Func Entrance ");
 708
 709         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 710         TAPI_RET_ERR_NUM_IF_FAIL(pCBConfig, TAPI_API_INVALID_PTR);
 711
 712         if ((pCBConfig->Net3gppType > 2) || (pCBConfig->MsgIdRangeCount < 0)) {
 713                 err("Invalid Input -3gppType(%d)",pCBConfig->Net3gppType);
 714                 err("Invalid Input -MsgIdRangeCount(%d)",pCBConfig->MsgIdRangeCount);
 715
 716                 return TAPI_API_INVALID_INPUT;
 717         }
 718
 719         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 720
 721         g_variant_builder_init( &b, G_VARIANT_TYPE("aa{sv}") );
 722
 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));
 731                 } else {
 732                         dbg("Unknown 3gpp type");
 733                         return FALSE;
 734                 }
 735                 g_variant_builder_add(&b, "{sv}", "Selected", g_variant_new_byte(pCBConfig->MsgIDs[i].Net3gpp.Selected));
 736                 g_variant_builder_close(&b);
 737         }
 738
 739         msgId = g_variant_builder_end(&b);
 740         packet_msgId = g_variant_new("v", msgId);
 741
 742         param = g_variant_new("(iiii@v)", pCBConfig->Net3gppType,
 743                                                         pCBConfig->CBEnabled,
 744                                                         pCBConfig->MsgIdMaxCount,
 745                                                         pCBConfig->MsgIdRangeCount,
 746                                                         packet_msgId);
 747
 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);
 753
 754         return TAPI_API_SUCCESS;
 755 }
 756
 757 EXPORT_API int tel_set_sms_memory_status(struct tapi_handle *handle, int memoryStatus, tapi_response_cb callback, void* user_data)
 758 {
 759         struct tapi_resp_data *evt_cb_data = NULL;
 760         GVariant *param;
 761
 762         dbg("Func Entrance ");
 763
 764         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 765
 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;
 769         }
 770
 771         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 772
 773         param = g_variant_new("(i)", memoryStatus);
 774
 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);
 780
 781         return TAPI_API_SUCCESS;
 782 }
 783
 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)
 788 {
 789         struct tapi_resp_data *evt_cb_data = NULL;
 790         GVariant *param;
 791         GVariant *sca = 0, *packet_sca = 0;
 792         GVariant *tpdu = 0, *packet_tpdu = 0;
 793         GVariantBuilder b;
 794         int i;
 795
 796         dbg("Func Entrance ");
 797
 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);
 801
 802         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 803
 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] );
 807         }
 808         sca = g_variant_builder_end(&b);
 809         packet_sca = g_variant_new("v", sca);
 810
 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] );
 814         }
 815         tpdu = g_variant_builder_end(&b);
 816         packet_tpdu = g_variant_new("v", tpdu);
 817
 818         param = g_variant_new("(@vi@vi)", packet_sca,
 819                                                         pDataPackage->MsgLength,
 820                                                         packet_tpdu,
 821                                                         RPCause);
 822
 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);
 828
 829         return TAPI_API_SUCCESS;
 830 }
 831
 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)
 833 {
 834         struct tapi_resp_data *evt_cb_data = NULL;
 835         GVariant *param;
 836
 837         dbg("Func Entrance ");
 838
 839         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 840
 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;
 845         }
 846
 847         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 848
 849         param = g_variant_new("(ii)", set_index, msgStatus);
 850
 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);
 856
 857         return TAPI_API_SUCCESS;
 858 }
 859
 860 EXPORT_API int tel_get_sms_parameters(struct tapi_handle *handle, int get_index, tapi_response_cb callback, void* user_data)
 861 {
 862         struct tapi_resp_data *evt_cb_data = NULL;
 863         GVariant *param;
 864
 865         dbg("Func Entrance ");
 866
 867         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 868         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
 869
 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;
 873         }
 874
 875         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 876
 877         param = g_variant_new("(i)", get_index);
 878
 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);
 884
 885         return TAPI_API_SUCCESS;
 886 }
 887
 888 EXPORT_API int tel_set_sms_parameters(struct tapi_handle *handle, const TelSmsParams_t *pSmsSetParameters, tapi_response_cb callback, void* user_data)
 889 {
 890         struct tapi_resp_data *evt_cb_data = NULL;
 891         GVariant *param;
 892         GVariant *alphaId = 0, *packet_alphaId = 0;
 893         GVariant *destDialNum = 0, *packet_destDialNum = 0;
 894         GVariant *scaDialNum = 0, *packet_scaDialNum = 0;
 895         GVariantBuilder b;
 896         int i;
 897
 898         dbg("Func Entrance ");
 899
 900         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 901         TAPI_RET_ERR_NUM_IF_FAIL(pSmsSetParameters, TAPI_API_INVALID_PTR);
 902
 903         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 904
 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] );
 908         }
 909         alphaId = g_variant_builder_end(&b);
 910         packet_alphaId = g_variant_new("v", alphaId);
 911
 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] );
 915         }
 916         destDialNum = g_variant_builder_end(&b);
 917         packet_destDialNum = g_variant_new("v", destDialNum);
 918
 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] );
 922         }
 923         scaDialNum = g_variant_builder_end(&b);
 924         packet_scaDialNum = g_variant_new("v", scaDialNum);
 925
 926         param = g_variant_new("(iii@viiii@viii@viii)", pSmsSetParameters->RecordIndex,
 927                                                                         pSmsSetParameters->RecordLen,
 928                                                                         pSmsSetParameters->AlphaIdLen,
 929                                                                         packet_alphaId,
 930                                                                         pSmsSetParameters->ParamIndicator,
 931                                                                         pSmsSetParameters->TpDestAddr.DialNumLen,
 932                                                                         pSmsSetParameters->TpDestAddr.Ton,
 933                                                                         pSmsSetParameters->TpDestAddr.Npi,
 934                                                                         packet_destDialNum,
 935                                                                         pSmsSetParameters->TpSvcCntrAddr.DialNumLen,
 936                                                                         pSmsSetParameters->TpSvcCntrAddr.Ton,
 937                                                                         pSmsSetParameters->TpSvcCntrAddr.Npi,
 938                                                                         packet_scaDialNum,
 939                                                                         pSmsSetParameters->TpProtocolId,
 940                                                                         pSmsSetParameters->TpDataCodingScheme,
 941                                                                         pSmsSetParameters->TpValidityPeriod);
 942
 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);
 948
 949         return TAPI_API_SUCCESS;
 950 }
 951
 952 EXPORT_API int tel_get_sms_parameter_count(struct tapi_handle *handle, tapi_response_cb callback, void* user_data)
 953 {
 954         struct tapi_resp_data *evt_cb_data = NULL;
 955
 956         dbg("Func Entrance ");
 957
 958         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 959         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
 960
 961         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 962
 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);
 968
 969         return TAPI_API_SUCCESS;
 970 }
 971
 972 EXPORT_API int tel_check_sms_device_status(struct tapi_handle *handle, int *pReadyStatus)
 973 {
 974         GError *error;
 975         GVariant *smsReady = NULL;
 976
 977         dbg("Func Entrance ");
 978
 979         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 980         TAPI_RET_ERR_NUM_IF_FAIL(pReadyStatus, TAPI_API_INVALID_PTR);
 981
 982         memset(pReadyStatus, 0, sizeof(int));
 983
 984         error = NULL;
 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);
 989         if(!smsReady){
 990                 dbg( "error to get SMS ready_status(%s)", error->message);
 991                 g_error_free (error);
 992                 return TAPI_API_OPERATION_FAILED;
 993         }
 994
 995         dbg("get SMS ready_status type_format(%s)", g_variant_get_type_string(smsReady));
 996
 997         g_variant_get(smsReady, "(b)", pReadyStatus);
 998         g_variant_unref(smsReady);
 999
1000         msg("************SMS_device_status (%d)", *pReadyStatus);
1001
1002         return TAPI_API_SUCCESS;
1003 }