wearable/src/tapi_sms.c

   1 /*
   2  * libslp-tapi
   3  *
   4  * Copyright (c) 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Ja-young Gu <jygu@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  */
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24
  25 #include "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
  46         CHECK_DEINIT(error);
  47
  48         if (!dbus_result) {
  49                 if (evt_cb_data) {
  50                         if (evt_cb_data->cb_fn) {
  51                                 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
  52                         }
  53
  54                         g_free(evt_cb_data);
  55                 }
  56
  57                 if (error)
  58                         g_error_free(error);
  59
  60                 return;
  61         }
  62
  63         dbg("on_response_default type_format(%s)", g_variant_get_type_string(dbus_result));
  64
  65         g_variant_get (dbus_result, "(i)", &result);
  66
  67         if (evt_cb_data) {
  68                 if (evt_cb_data->cb_fn) {
  69                         evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
  70                 }
  71
  72                 g_free(evt_cb_data);
  73         }
  74 }
  75
  76 static void on_response_read_msg(GObject *source_object, GAsyncResult *res, gpointer user_data)
  77 {
  78         GError *error = NULL;
  79         GDBusConnection *conn = NULL;
  80         struct tapi_resp_data *evt_cb_data = user_data;
  81         int result = -1;
  82
  83         TelSmsData_t    readMsg = {0,};
  84         GVariant *dbus_result = NULL;
  85
  86         GVariant *sca = 0, *tpdu = 0;
  87         int i = 0;
  88         GVariantIter *iter = 0;
  89         GVariant *inner_gv = 0;
  90
  91         conn = G_DBUS_CONNECTION (source_object);
  92         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
  93         CHECK_DEINIT(error);
  94
  95         if (!dbus_result) {
  96                 if (evt_cb_data) {
  97                         if (evt_cb_data->cb_fn) {
  98                                 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
  99                         }
 100
 101                         g_free(evt_cb_data);
 102                 }
 103
 104                 if (error)
 105                         g_error_free(error);
 106
 107                 return;
 108         }
 109
 110         dbg("on_response_read_msg type_format(%s)", g_variant_get_type_string(dbus_result));
 111
 112 //      readMsg.SimIndex = 0xFFFFFFFF;
 113         g_variant_get (dbus_result, "(iii@vi@v)", &result,
 114                         &readMsg.SimIndex,
 115                         &readMsg.MsgStatus,
 116                         &sca,
 117                         &readMsg.SmsData.MsgLength,
 118                         &tpdu);
 119
 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] ) ) {
 123                 i++;
 124                 if( i >= TAPI_SIM_SMSP_ADDRESS_LEN )
 125                         break;
 126         }
 127
 128         inner_gv = g_variant_get_variant( tpdu );
 129         g_variant_get(inner_gv, "ay", &iter);
 130         i= 0;
 131         while( g_variant_iter_loop(iter, "y", &readMsg.SmsData.szData[i]) ) {
 132                 i++;
 133                 if( i >= TAPI_NETTEXT_SMDATA_SIZE_MAX + 1 )
 134                         break;
 135         }
 136         g_variant_iter_free(iter);
 137         g_variant_unref(inner_gv);
 138
 139         if (evt_cb_data) {
 140                 if (evt_cb_data->cb_fn) {
 141                         evt_cb_data->cb_fn(evt_cb_data->handle, result, &readMsg, evt_cb_data->user_data);
 142                 }
 143
 144                 g_free(evt_cb_data);
 145         }
 146 }
 147
 148 static void on_response_write_msg(GObject *source_object, GAsyncResult *res, gpointer user_data)
 149 {
 150         GError *error = NULL;
 151         GDBusConnection *conn = NULL;
 152         struct tapi_resp_data *evt_cb_data = user_data;
 153         int result = -1;
 154         int index = 0;
 155
 156         GVariant *dbus_result = NULL;
 157
 158         conn = G_DBUS_CONNECTION (source_object);
 159         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 160         CHECK_DEINIT(error);
 161
 162         if (!dbus_result) {
 163                 if (evt_cb_data) {
 164                         if (evt_cb_data->cb_fn) {
 165                                 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 166                         }
 167
 168                         g_free(evt_cb_data);
 169                 }
 170
 171                 if (error)
 172                         g_error_free(error);
 173
 174                 return;
 175         }
 176
 177         dbg("on_response_write_msg type_format(%s)", g_variant_get_type_string(dbus_result));
 178
 179         g_variant_get (dbus_result, "(ii)", &result, &index);
 180
 181         if (evt_cb_data) {
 182                 if (evt_cb_data->cb_fn) {
 183                         evt_cb_data->cb_fn(evt_cb_data->handle, result, &index, evt_cb_data->user_data);
 184                 }
 185
 186                 g_free(evt_cb_data);
 187         }
 188 }
 189
 190 static void on_response_delete_msg(GObject *source_object, GAsyncResult *res, gpointer user_data)
 191 {
 192         GError *error = NULL;
 193         GDBusConnection *conn = NULL;
 194         struct tapi_resp_data *evt_cb_data = user_data;
 195         int result = -1;
 196         int index = -1;
 197
 198         GVariant *dbus_result = NULL;
 199
 200         conn = G_DBUS_CONNECTION (source_object);
 201         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 202         CHECK_DEINIT(error);
 203
 204         if (!dbus_result) {
 205                 if (evt_cb_data) {
 206                         if (evt_cb_data->cb_fn) {
 207                                 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 208                         }
 209
 210                         g_free(evt_cb_data);
 211                 }
 212
 213                 if (error)
 214                         g_error_free(error);
 215
 216                 return;
 217         }
 218
 219         dbg("on_response_delete_msg type_format(%s)", g_variant_get_type_string(dbus_result));
 220
 221         g_variant_get (dbus_result, "(ii)", &result, &index);
 222
 223         if (evt_cb_data) {
 224                 if (evt_cb_data->cb_fn) {
 225                         evt_cb_data->cb_fn(evt_cb_data->handle, result, &index, evt_cb_data->user_data);
 226                 }
 227
 228                 g_free(evt_cb_data);
 229         }
 230 }
 231
 232 static void on_response_get_msg_count(GObject *source_object, GAsyncResult *res, gpointer user_data)
 233 {
 234         GError *error = NULL;
 235         GDBusConnection *conn = NULL;
 236         struct tapi_resp_data *evt_cb_data = user_data;
 237         int result = -1;
 238         TelSmsStoredMsgCountInfo_t storedMsgCnt = {0,};
 239
 240         GVariant *dbus_result = NULL;
 241         int i = 0;
 242         int idx = 0;
 243         GVariantIter *iter = NULL;
 244
 245         conn = G_DBUS_CONNECTION (source_object);
 246         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 247         CHECK_DEINIT(error);
 248
 249         if (!dbus_result) {
 250                 if (evt_cb_data) {
 251                         if (evt_cb_data->cb_fn) {
 252                                 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 253                         }
 254
 255                         g_free(evt_cb_data);
 256                 }
 257
 258                 if (error)
 259                         g_error_free(error);
 260
 261                 return;
 262         }
 263
 264         dbg("on_response_get_msg_count type_format(%s)", g_variant_get_type_string(dbus_result));
 265
 266         g_variant_get (dbus_result, "(iiiai)", &result,
 267                                                                 &storedMsgCnt.TotalCount,
 268                                                                 &storedMsgCnt.UsedCount,
 269                                                                 &iter);
 270
 271         i = 0;
 272         while (g_variant_iter_loop(iter, "i", &idx)) {
 273                 storedMsgCnt.IndexList[i] = idx;
 274                 i++;
 275                 if (i >= TAPI_NETTEXT_GSM_SMS_MSG_NUM_MAX)
 276                         break;
 277         }
 278
 279         if (evt_cb_data) {
 280                 if (evt_cb_data->cb_fn) {
 281                         evt_cb_data->cb_fn(evt_cb_data->handle, result, &storedMsgCnt, evt_cb_data->user_data);
 282                 }
 283
 284                 g_free(evt_cb_data);
 285         }
 286
 287 }
 288
 289 static void on_response_get_sca(GObject *source_object, GAsyncResult *res, gpointer user_data)
 290 {
 291         GError *error = NULL;
 292         GDBusConnection *conn = NULL;
 293         struct tapi_resp_data *evt_cb_data = user_data;
 294         int result = -1;
 295         TelSmsAddressInfo_t scaInfo = {0,};
 296
 297         GVariant *dbus_result = NULL;
 298
 299         GVariant *num = 0;
 300         int i = 0;
 301         GVariantIter *iter = 0;
 302         GVariant *inner_gv = 0;
 303
 304
 305         conn = G_DBUS_CONNECTION (source_object);
 306         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 307         CHECK_DEINIT(error);
 308
 309         if (!dbus_result) {
 310                 if (evt_cb_data) {
 311                         if (evt_cb_data->cb_fn) {
 312                                 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 313                         }
 314
 315                         g_free(evt_cb_data);
 316                 }
 317
 318                 if (error)
 319                         g_error_free(error);
 320
 321                 return;
 322         }
 323
 324         dbg("on_response_get_sca type_format(%s)", g_variant_get_type_string(dbus_result));
 325
 326         g_variant_get (dbus_result, "(iiii@v)", &result,
 327                                         &scaInfo.Ton,
 328                                         &scaInfo.Npi,
 329                                         &scaInfo.DialNumLen,
 330                                         &num);
 331
 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] ) ) {
 335                 i++;
 336                 if( i >= TAPI_SIM_SMSP_ADDRESS_LEN + 1 )
 337                         break;
 338         }
 339         g_variant_iter_free(iter);
 340         g_variant_unref(inner_gv);
 341
 342         if (evt_cb_data) {
 343                 if (evt_cb_data->cb_fn) {
 344                         evt_cb_data->cb_fn(evt_cb_data->handle, result, &scaInfo, evt_cb_data->user_data);
 345                 }
 346
 347                 g_free(evt_cb_data);
 348         }
 349 }
 350
 351 static void on_response_get_cb_config(GObject *source_object, GAsyncResult *res, gpointer user_data)
 352 {
 353         GError *error = NULL;
 354         GDBusConnection *conn = NULL;
 355         struct tapi_resp_data *evt_cb_data = user_data;
 356         int result = -1;
 357         int i;
 358         TelSmsCbConfig_t cbConfig = {0,};
 359
 360         GVariant *dbus_result = NULL;
 361         GVariant *value = NULL;
 362         GVariantIter *iter = NULL;
 363         GVariantIter *iter_row = NULL;
 364         const gchar *key = NULL;
 365
 366         conn = G_DBUS_CONNECTION (source_object);
 367         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 368         CHECK_DEINIT(error);
 369
 370         if (!dbus_result) {
 371                 if (evt_cb_data) {
 372                         if (evt_cb_data->cb_fn) {
 373                                 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 374                         }
 375
 376                         g_free(evt_cb_data);
 377                 }
 378
 379                 if (error)
 380                         g_error_free(error);
 381
 382                 return;
 383         }
 384
 385         dbg("on_response_get_cb_config type_format(%s)", g_variant_get_type_string(dbus_result));
 386
 387         g_variant_get (dbus_result, "(iiiiiaa{sv})", &result,
 388                                         &cbConfig.Net3gppType,
 389                                         &cbConfig.CBEnabled,
 390                                         &cbConfig.MsgIdMaxCount,
 391                                         &cbConfig.MsgIdRangeCount,
 392                                         &iter);
 393
 394         i = 0;
 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);
 399                         }
 400                         if (!g_strcmp0(key, "ToMsgId")) {
 401                                 cbConfig.MsgIDs[i].Net3gpp.ToMsgId = g_variant_get_uint16(value);
 402                         }
 403                         if (!g_strcmp0(key, "CBCategory")) {
 404                                 cbConfig.MsgIDs[i].Net3gpp2.CBCategory = g_variant_get_uint16(value);
 405                         }
 406                         if (!g_strcmp0(key, "CBLanguage")) {
 407                                 cbConfig.MsgIDs[i].Net3gpp2.CBLanguage = g_variant_get_uint16(value);
 408                         }
 409                         if (!g_strcmp0(key, "Selected")) {
 410                                 cbConfig.MsgIDs[i].Net3gpp.Selected = g_variant_get_byte(value);
 411                         }
 412                 }
 413                 i++;
 414                 g_variant_iter_free(iter_row);
 415         }
 416         g_variant_iter_free(iter);
 417
 418         if (evt_cb_data) {
 419                 if (evt_cb_data->cb_fn) {
 420                         evt_cb_data->cb_fn(evt_cb_data->handle, result, &cbConfig, evt_cb_data->user_data);
 421                 }
 422
 423                 g_free(evt_cb_data);
 424         }
 425 }
 426
 427 static void on_response_get_sms_params(GObject *source_object, GAsyncResult *res, gpointer user_data)
 428 {
 429         GError *error = NULL;
 430         GDBusConnection *conn = NULL;
 431         struct tapi_resp_data *evt_cb_data = user_data;
 432         int result = -1;
 433         TelSmsParams_t paramInfo = {0,};
 434
 435         GVariant *dbus_result = NULL;
 436
 437         GVariant *alphaId = 0, *destDialNum = 0, *scaDialNum = 0;
 438         int i = 0;
 439         GVariantIter *iter = 0;
 440         GVariant *inner_gv = 0;
 441
 442         conn = G_DBUS_CONNECTION (source_object);
 443         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 444         CHECK_DEINIT(error);
 445
 446         if (!dbus_result) {
 447                 if (evt_cb_data) {
 448                         if (evt_cb_data->cb_fn) {
 449                                 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 450                         }
 451
 452                         g_free(evt_cb_data);
 453                 }
 454
 455                 if (error)
 456                         g_error_free(error);
 457
 458                 return;
 459         }
 460
 461         dbg("on_response_get_sms_params type_format(%s)", g_variant_get_type_string(dbus_result));
 462
 463         g_variant_get (dbus_result, "(iiii@viiii@viii@viii)", &result,
 464                                                                 &paramInfo.RecordIndex,
 465                                                                 &paramInfo.RecordLen,
 466                                                                 &paramInfo.AlphaIdLen,
 467                                                                 &alphaId,
 468                                                                 &paramInfo.ParamIndicator,
 469                                                                 &paramInfo.TpDestAddr.DialNumLen,
 470                                                                 &paramInfo.TpDestAddr.Ton,
 471                                                                 &paramInfo.TpDestAddr.Npi,
 472                                                                 &destDialNum,
 473                                                                 &paramInfo.TpSvcCntrAddr.DialNumLen,
 474                                                                 &paramInfo.TpSvcCntrAddr.Ton,
 475                                                                 &paramInfo.TpSvcCntrAddr.Npi,
 476                                                                 &scaDialNum,
 477                                                                 &paramInfo.TpProtocolId,
 478                                                                 &paramInfo.TpDataCodingScheme,
 479                                                                 &paramInfo.TpValidityPeriod);
 480
 481         inner_gv = g_variant_get_variant( alphaId );
 482         g_variant_get(inner_gv, "ay", &iter);
 483         while( g_variant_iter_loop(iter, "y", &paramInfo.szAlphaId[i] ) ) {
 484                 i++;
 485                 if( i >= TAPI_SIM_SMSP_ALPHA_ID_LEN_MAX + 1 )
 486                         break;
 487         }
 488
 489         inner_gv = g_variant_get_variant( destDialNum );
 490         g_variant_get(inner_gv, "ay", &iter);
 491         i = 0;
 492         while( g_variant_iter_loop(iter, "y", &paramInfo.TpDestAddr.szDiallingNum[i] ) ) {
 493                 i++;
 494                 if( i >= TAPI_SIM_SMSP_ADDRESS_LEN + 1 )
 495                         break;
 496         }
 497
 498         inner_gv = g_variant_get_variant( scaDialNum );
 499         g_variant_get(inner_gv, "ay", &iter);
 500         i = 0;
 501         while( g_variant_iter_loop(iter, "y", &paramInfo.TpSvcCntrAddr.szDiallingNum[i] ) ) {
 502                 i++;
 503                 if( i >= TAPI_SIM_SMSP_ADDRESS_LEN + 1 )
 504                         break;
 505         }
 506
 507         g_variant_iter_free(iter);
 508         g_variant_unref(inner_gv);
 509
 510         if (evt_cb_data) {
 511                 if (evt_cb_data->cb_fn) {
 512                         evt_cb_data->cb_fn(evt_cb_data->handle, result, &paramInfo, evt_cb_data->user_data);
 513                 }
 514
 515                 g_free(evt_cb_data);
 516         }
 517
 518 }
 519
 520 static void on_response_get_sms_param_cnt(GObject *source_object, GAsyncResult *res, gpointer user_data)
 521 {
 522         GError *error = NULL;
 523         GDBusConnection *conn = NULL;
 524         struct tapi_resp_data *evt_cb_data = user_data;
 525         int result = -1;
 526         int recordCount = 0;
 527
 528         GVariant *dbus_result = NULL;
 529
 530         conn = G_DBUS_CONNECTION (source_object);
 531         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 532         CHECK_DEINIT(error);
 533
 534         if (!dbus_result) {
 535                 if (evt_cb_data) {
 536                         if (evt_cb_data->cb_fn) {
 537                                 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 538                         }
 539
 540                         g_free(evt_cb_data);
 541                 }
 542
 543                 if (error)
 544                         g_error_free(error);
 545
 546                 return;
 547         }
 548
 549         dbg("on_response_get_sms_param_cnt type_format(%s)", g_variant_get_type_string(dbus_result));
 550
 551         g_variant_get (dbus_result, "(ii)", &result,
 552                         &recordCount);
 553
 554         if (evt_cb_data) {
 555                 if (evt_cb_data->cb_fn) {
 556                         evt_cb_data->cb_fn(evt_cb_data->handle, result, &recordCount, evt_cb_data->user_data);
 557                 }
 558
 559                 g_free(evt_cb_data);
 560         }
 561 }
 562
 563 EXPORT_API int tel_send_sms(struct tapi_handle *handle,
 564                 const TelSmsDatapackageInfo_t *pDataPackage,
 565                 int bMoreMsgToSend,
 566                 tapi_response_cb callback, void* user_data)
 567 {
 568         struct tapi_resp_data *evt_cb_data = NULL;
 569         GVariant *param;
 570         GVariant *sca = 0, *packet_sca = 0;
 571         GVariant *tpdu = 0, *packet_tpdu = 0;
 572         GVariantBuilder *b = 0;
 573         int i;
 574         int emergency_mode = 0;
 575
 576         dbg("Func Entrance ");
 577
 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);
 581 #if 0
 582         if (vconf_get_int("db/telephony/emergency", &emergency_mode) != 0) {
 583                 err("[FAIL]GET db/telephony/emergency");
 584                 return TAPI_API_OPERATION_FAILED;
 585         }
 586 #endif
 587
 588         if (emergency_mode) {
 589                 dbg("emergency mode on");
 590                 return TAPI_API_OPERATION_FAILED;
 591         }
 592
 593         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 594
 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] );
 598         }
 599         sca = g_variant_builder_end(b);
 600         packet_sca = g_variant_new("v", sca);
 601
 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] );
 605         }
 606         tpdu = g_variant_builder_end(b);
 607         packet_tpdu = g_variant_new("v", tpdu);
 608
 609         param = g_variant_new("(@vi@vi)", packet_sca,
 610                                                         pDataPackage->MsgLength,
 611                                                         packet_tpdu,
 612                                                         bMoreMsgToSend);
 613
 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);
 619
 620         return TAPI_API_SUCCESS;
 621 }
 622
 623 EXPORT_API int tel_read_sms_in_sim(struct tapi_handle *handle, int index, tapi_response_cb callback, void* user_data)
 624 {
 625         struct tapi_resp_data *evt_cb_data = NULL;
 626         GVariant *param;
 627
 628         dbg("Func Entrance ");
 629
 630         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 631         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
 632
 633         if( (index < 0) || (index > TAPI_NETTEXT_MAX_INDEX) ) {
 634                 err("Invalid Input -Read SMS %d",index);
 635
 636                 return TAPI_API_INVALID_INPUT;
 637         }
 638
 639         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 640
 641         param = g_variant_new("(i)", index);
 642
 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);
 648
 649         return TAPI_API_SUCCESS;
 650 }
 651
 652 EXPORT_API int tel_write_sms_in_sim(struct tapi_handle *handle, const TelSmsData_t *pWriteData, tapi_response_cb callback, void* user_data)
 653 {
 654         struct tapi_resp_data *evt_cb_data = NULL;
 655         GVariant *param;
 656         GVariant *sca = 0, *packet_sca = 0;
 657         GVariant *tpdu = 0, *packet_tpdu = 0;
 658         GVariantBuilder *b = 0;
 659         int i;
 660
 661         dbg("Func Entrance ");
 662
 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);
 666
 667         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 668
 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] );
 672         }
 673         sca = g_variant_builder_end(b);
 674         packet_sca = g_variant_new("v", sca);
 675
 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] );
 679         }
 680         tpdu = g_variant_builder_end(b);
 681         packet_tpdu = g_variant_new("v", tpdu);
 682
 683         param = g_variant_new("(i@vi@v)", pWriteData->MsgStatus,
 684                                                         packet_sca,
 685                                                         pWriteData->SmsData.MsgLength,
 686                                                         packet_tpdu);
 687
 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);
 693
 694         return TAPI_API_SUCCESS;
 695 }
 696
 697 EXPORT_API int tel_delete_sms_in_sim(struct tapi_handle *handle, int index, tapi_response_cb callback, void* user_data)
 698 {
 699         struct tapi_resp_data *evt_cb_data = NULL;
 700         GVariant *param;
 701
 702         dbg("Func Entrance ");
 703
 704         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 705         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
 706
 707         if ((index < -1) || (index > TAPI_NETTEXT_MAX_INDEX)) {
 708                 err("Invalid Index Input");
 709                 return TAPI_API_INVALID_INPUT;
 710         }
 711
 712         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 713
 714         param = g_variant_new("(i)", index);
 715
 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);
 721
 722         return TAPI_API_SUCCESS;
 723 }
 724
 725 EXPORT_API int tel_get_sms_count(struct tapi_handle *handle, tapi_response_cb callback, void* user_data)
 726 {
 727         struct tapi_resp_data *evt_cb_data = NULL;
 728
 729         dbg("Func Entrance ");
 730
 731         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 732         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
 733
 734         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 735
 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);
 741
 742         return TAPI_API_SUCCESS;
 743 }
 744
 745 EXPORT_API int tel_get_sms_sca(struct tapi_handle *handle, int index, tapi_response_cb callback, void* user_data)
 746 {
 747         struct tapi_resp_data *evt_cb_data = NULL;
 748         GVariant *param;
 749
 750         dbg("Func Entrance ");
 751
 752         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 753         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
 754
 755         if ((index < 0) || (index > TAPI_NETTEXT_MAX_INDEX)) {
 756                 err("Invalid Index Input");
 757                 return TAPI_API_INVALID_INPUT;
 758         }
 759
 760         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 761
 762         param = g_variant_new("(i)", index);
 763
 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);
 769
 770         return TAPI_API_SUCCESS;
 771 }
 772
 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)
 774 {
 775         struct tapi_resp_data *evt_cb_data = NULL;
 776         GVariant *param;
 777         GVariant *sca = 0, *packet_sca = 0;
 778         GVariantBuilder *b = 0;
 779         int i;
 780
 781         dbg("Func Entrance ");
 782
 783         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 784         TAPI_RET_ERR_NUM_IF_FAIL(pSCA, TAPI_API_INVALID_PTR);
 785
 786         if ((index < 0) || (index > TAPI_NETTEXT_MAX_INDEX)) {
 787                 err("Invalid Index Input");
 788                 return TAPI_API_INVALID_INPUT;
 789         }
 790
 791         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 792
 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] );
 796         }
 797         sca = g_variant_builder_end(b);
 798         packet_sca = g_variant_new("v", sca);
 799
 800         param = g_variant_new("(iiii@v)", index,
 801                                                         pSCA->Ton,
 802                                                         pSCA->Npi,
 803                                                         pSCA->DialNumLen,
 804                                                         packet_sca);
 805
 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);
 811
 812         return TAPI_API_SUCCESS;
 813 }
 814
 815 EXPORT_API int tel_get_sms_cb_config(struct tapi_handle *handle, tapi_response_cb callback, void* user_data)
 816 {
 817         struct tapi_resp_data *evt_cb_data = NULL;
 818
 819         dbg("Func Entrance ");
 820
 821         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 822         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
 823
 824         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 825
 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);
 831
 832         return TAPI_API_SUCCESS;
 833 }
 834
 835 EXPORT_API int tel_set_sms_cb_config(struct tapi_handle *handle, const TelSmsCbConfig_t *pCBConfig, tapi_response_cb callback, void* user_data)
 836 {
 837         struct tapi_resp_data *evt_cb_data = NULL;
 838         GVariant *param;
 839         GVariant *msgId = 0, *packet_msgId = 0;
 840         GVariantBuilder b;
 841         int i = 0;
 842
 843         dbg("Func Entrance ");
 844
 845         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 846         TAPI_RET_ERR_NUM_IF_FAIL(pCBConfig, TAPI_API_INVALID_PTR);
 847
 848         if ((pCBConfig->Net3gppType > 2) || (pCBConfig->MsgIdRangeCount < 0)) {
 849                 err("Invalid Input -3gppType(%d)",pCBConfig->Net3gppType);
 850                 err("Invalid Input -MsgIdRangeCount(%d)",pCBConfig->MsgIdRangeCount);
 851
 852                 return TAPI_API_INVALID_INPUT;
 853         }
 854
 855         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 856
 857         g_variant_builder_init( &b, G_VARIANT_TYPE("aa{sv}") );
 858
 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));
 867                 } else {
 868                         dbg("Unknown 3gpp type");
 869                         return FALSE;
 870                 }
 871                 g_variant_builder_add(&b, "{sv}", "Selected", g_variant_new_byte(pCBConfig->MsgIDs[i].Net3gpp.Selected));
 872                 g_variant_builder_close(&b);
 873         }
 874
 875         msgId = g_variant_builder_end(&b);
 876         packet_msgId = g_variant_new("v", msgId);
 877
 878         param = g_variant_new("(iiii@v)", pCBConfig->Net3gppType,
 879                                                         pCBConfig->CBEnabled,
 880                                                         pCBConfig->MsgIdMaxCount,
 881                                                         pCBConfig->MsgIdRangeCount,
 882                                                         packet_msgId);
 883
 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);
 889
 890         return TAPI_API_SUCCESS;
 891 }
 892
 893 EXPORT_API int tel_set_sms_memory_status(struct tapi_handle *handle, int memoryStatus, tapi_response_cb callback, void* user_data)
 894 {
 895         struct tapi_resp_data *evt_cb_data = NULL;
 896         GVariant *param;
 897
 898         dbg("Func Entrance ");
 899
 900         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 901
 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;
 905         }
 906
 907         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 908
 909         param = g_variant_new("(i)", memoryStatus);
 910
 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);
 916
 917         return TAPI_API_SUCCESS;
 918 }
 919
 920 EXPORT_API int tel_get_sms_preferred_bearer(struct tapi_handle *handle, tapi_response_cb callback, void* user_data)
 921 {
 922         struct tapi_resp_data *evt_cb_data = NULL;
 923
 924         dbg("Func Entrance ");
 925
 926         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 927         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
 928
 929         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 930
 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);
 936
 937         return TAPI_API_SUCCESS;
 938 }
 939
 940 EXPORT_API int tel_set_sms_preferred_bearer(struct tapi_handle *handle, TelSmsBearerType_t BearerType, tapi_response_cb callback, void* user_data)
 941 {
 942         struct tapi_resp_data *evt_cb_data = NULL;
 943         GVariant *param;
 944
 945         dbg("Func Entrance ");
 946
 947         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 948
 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;
 952         }
 953
 954         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 955
 956         param = g_variant_new("(i)", BearerType);
 957
 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);
 963
 964         return TAPI_API_SUCCESS;
 965 }
 966
 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)
 971 {
 972         struct tapi_resp_data *evt_cb_data = NULL;
 973         GVariant *param;
 974         GVariant *sca = 0, *packet_sca = 0;
 975         GVariant *tpdu = 0, *packet_tpdu = 0;
 976         GVariantBuilder *b = 0;
 977         int i;
 978
 979         dbg("Func Entrance ");
 980
 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);
 984
 985         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 986
 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] );
 990         }
 991         sca = g_variant_builder_end(b);
 992         packet_sca = g_variant_new("v", sca);
 993
 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] );
 997         }
 998         tpdu = g_variant_builder_end(b);
 999         packet_tpdu = g_variant_new("v", tpdu);
1000
1001         param = g_variant_new("(@vi@vi)", packet_sca,
1002                                                         pDataPackage->MsgLength,
1003                                                         packet_tpdu,
1004                                                         RPCause);
1005
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);
1011
1012         return TAPI_API_SUCCESS;
1013 }
1014
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)
1016 {
1017         struct tapi_resp_data *evt_cb_data = NULL;
1018         GVariant *param;
1019
1020         dbg("Func Entrance ");
1021
1022         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1023
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;
1028         }
1029
1030         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1031
1032         param = g_variant_new("(ii)", index, msgStatus);
1033
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);
1039
1040         return TAPI_API_SUCCESS;
1041 }
1042
1043 EXPORT_API int tel_get_sms_parameters(struct tapi_handle *handle, int index, tapi_response_cb callback, void* user_data)
1044 {
1045         struct tapi_resp_data *evt_cb_data = NULL;
1046         GVariant *param;
1047
1048         dbg("Func Entrance ");
1049
1050         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1051         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
1052
1053         if ((index < 0) || (index > TAPI_NETTEXT_MAX_INDEX)) {
1054                 err("Invalid Input -SMS Param Get Nettext");
1055                 return TAPI_API_INVALID_INPUT;
1056         }
1057
1058         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1059
1060         param = g_variant_new("(i)", index);
1061
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);
1067
1068         return TAPI_API_SUCCESS;
1069 }
1070
1071 EXPORT_API int tel_set_sms_parameters(struct tapi_handle *handle, const TelSmsParams_t *pSmsSetParameters, tapi_response_cb callback, void* user_data)
1072 {
1073         struct tapi_resp_data *evt_cb_data = NULL;
1074         GVariant *param;
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;
1079         int i;
1080
1081         dbg("Func Entrance ");
1082
1083         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1084         TAPI_RET_ERR_NUM_IF_FAIL(pSmsSetParameters, TAPI_API_INVALID_PTR);
1085
1086         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1087
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] );
1091         }
1092         alphaId = g_variant_builder_end(b);
1093         packet_alphaId = g_variant_new("v", alphaId);
1094
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] );
1098         }
1099         destDialNum = g_variant_builder_end(b);
1100         packet_destDialNum = g_variant_new("v", destDialNum);
1101
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] );
1105         }
1106         scaDialNum = g_variant_builder_end(b);
1107         packet_scaDialNum = g_variant_new("v", scaDialNum);
1108
1109         param = g_variant_new("(iii@viiii@viii@viii)", pSmsSetParameters->RecordIndex,
1110                                                                         pSmsSetParameters->RecordLen,
1111                                                                         pSmsSetParameters->AlphaIdLen,
1112                                                                         packet_alphaId,
1113                                                                         pSmsSetParameters->ParamIndicator,
1114                                                                         pSmsSetParameters->TpDestAddr.DialNumLen,
1115                                                                         pSmsSetParameters->TpDestAddr.Ton,
1116                                                                         pSmsSetParameters->TpDestAddr.Npi,
1117                                                                         packet_destDialNum,
1118                                                                         pSmsSetParameters->TpSvcCntrAddr.DialNumLen,
1119                                                                         pSmsSetParameters->TpSvcCntrAddr.Ton,
1120                                                                         pSmsSetParameters->TpSvcCntrAddr.Npi,
1121                                                                         packet_scaDialNum,
1122                                                                         pSmsSetParameters->TpProtocolId,
1123                                                                         pSmsSetParameters->TpDataCodingScheme,
1124                                                                         pSmsSetParameters->TpValidityPeriod);
1125
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);
1131
1132         return TAPI_API_SUCCESS;
1133 }
1134
1135 EXPORT_API int tel_get_sms_parameter_count(struct tapi_handle *handle, tapi_response_cb callback, void* user_data)
1136 {
1137         struct tapi_resp_data *evt_cb_data = NULL;
1138
1139         dbg("Func Entrance ");
1140
1141         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1142         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
1143
1144         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1145
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);
1151
1152         return TAPI_API_SUCCESS;
1153 }
1154
1155 #if 0
1156 /**
1157  *
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.
1161  *
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.
1164  *
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.
1168  *
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
1172  *
1173  * @Interface           Asynchronous.
1174  * @remark
1175  * @Refer               TelSmsMsgInfo_t.
1176  */
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)
1178 {
1179         struct tapi_resp_data *evt_cb_data = NULL;
1180         GVariant *param;
1181
1182         dbg("Func Entrance ");
1183
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;
1188
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;
1192         }
1193         if (emergency_mode) {
1194                 TAPI_LIB_DEBUG(LEVEL_DEBUG, "emergency mode on");
1195                 return TAPI_API_OPERATION_FAILED;
1196         }
1197
1198         TAPI_RET_ERR_NUM_IF_FAIL(pSmsMsgInfo ,TAPI_API_INVALID_PTR);
1199
1200         if (conn_name.length_of_name == 0) {
1201                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
1202                 return TAPI_API_OPERATION_FAILED;
1203         }
1204
1205         TAPI_RET_ERR_NUM_IF_FAIL(tapi_check_dbus_status(), TAPI_API_SYSTEM_RPC_LINK_NOT_EST);
1206         TAPI_GLIB_INIT_PARAMS();
1207
1208         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,
1209                         out_param1,out_param2,out_param3,out_param4);
1210
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));
1214
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);
1217
1218         if (ret) {
1219                 api_err = g_array_index(out_param1, int, 0);
1220         }
1221         else {
1222                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
1223         }
1224
1225         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,
1226                         out_param1,out_param2,out_param3,out_param4);
1227
1228         return api_err;
1229 }
1230 #endif
1231
1232 EXPORT_API int tel_check_sms_device_status(struct tapi_handle *handle, int *pReadyStatus)
1233 {
1234         GError *error;
1235         GVariant *smsReady = NULL;
1236
1237         dbg("Func Entrance ");
1238
1239         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1240         TAPI_RET_ERR_NUM_IF_FAIL(pReadyStatus, TAPI_API_INVALID_PTR);
1241
1242         memset(pReadyStatus, 0, sizeof(int));
1243
1244         error = NULL;
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);
1247
1248         if(!smsReady){
1249                 dbg( "error to get SMS ready_status(%s)", error->message);
1250                 g_error_free (error);
1251                 return TAPI_API_OPERATION_FAILED;
1252         }
1253
1254         dbg("get SMS ready_status type_format(%s)", g_variant_get_type_string(smsReady));
1255
1256         g_variant_get(smsReady, "(b)", pReadyStatus);
1257
1258         dbg("************SMS_device_status (%d)", *pReadyStatus);
1259
1260         return TAPI_API_SUCCESS;
1261 }
1262
1263 #if 0
1264 /**
1265  *
1266  * This function enables to application to set that the device is ready to recieve messages from network.
1267  *
1268  * @return              Returns appropriate error code. Refer TapiResult_t .
1269  * @param[in]           None
1270  *
1271  * @param[out]  None
1272  * @Interface           Synchronous.
1273  * @remark
1274  * @Refer
1275  */
1276 EXPORT_API int tel_set_sms_device_status(struct tapi_handle *handle)
1277 {
1278         struct tapi_resp_data *evt_cb_data = NULL;
1279         GVariant *param;
1280
1281         dbg("Func Entrance ");
1282
1283         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1284
1285         TS_BOOL ret = FALSE;
1286         int api_err = TAPI_API_SUCCESS;
1287
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);
1291
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);
1295
1296         if (ret) {
1297                 api_err = g_array_index(out_param1, int, 0);
1298         }
1299         else {
1300                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
1301         }
1302
1303         TAPI_GLIB_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param1, out_param2, out_param3, out_param4);
1304
1305         return api_err;
1306 }
1307 #endif
1308 //eof