wearable/src/tapi_phonebook.c

   1 /*
   2  * libslp-tapi
   3  *
   4  * Copyright (c) 2012 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
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25
  26 #include "tapi_common.h"
  27 #include "TapiUtility.h"
  28 #include "TelSim.h"
  29
  30 #include "common.h"
  31 #include "tapi_log.h"
  32 #include "ITapiPhonebook.h"
  33
  34 static void move_str (char *dest, unsigned int len, gchar *src)
  35 {
  36         if (!dest || !src)
  37                 return;
  38
  39         if (strlen (src) == 0)
  40                 return;
  41
  42         snprintf (dest, len, "%s", src);
  43         g_free (src);
  44 }
  45
  46 static void on_response_get_sim_pb_count(GObject *source_object, GAsyncResult *res, gpointer user_data)
  47 {
  48         GError *error = NULL;
  49         GDBusConnection *conn = NULL;
  50         GVariant *dbus_result;
  51
  52         struct tapi_resp_data *evt_cb_data = user_data;
  53         TelSimPbAccessResult_t result = TAPI_SIM_PB_SUCCESS;
  54         TelSimPbStorageInfo_t pb_cnt ;
  55         gint used = 0, total = 0;
  56
  57         memset(&pb_cnt, 0, sizeof(TelSimPbStorageInfo_t));
  58
  59         conn = G_DBUS_CONNECTION (source_object);
  60         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
  61         CHECK_DEINIT(error);
  62
  63         if (!dbus_result) {
  64                 if (evt_cb_data->cb_fn) {
  65                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
  66                 }
  67
  68                 if (error)
  69                         g_error_free(error);
  70
  71                 g_free(evt_cb_data);
  72                 return;
  73         }
  74
  75         g_variant_get (dbus_result, "(iiii)",
  76                         &result,
  77                         &pb_cnt.StorageFileType,
  78                         &used,
  79                         &total);
  80
  81         pb_cnt.UsedRecordCount = used;
  82         pb_cnt.TotalRecordCount = total;
  83
  84         if (evt_cb_data->cb_fn) {
  85                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &pb_cnt, evt_cb_data->user_data);
  86         }
  87
  88         g_free(evt_cb_data);
  89 }
  90
  91 static void on_response_get_sim_pb_meta_info(GObject *source_object, GAsyncResult *res, gpointer user_data)
  92 {
  93         GError *error = NULL;
  94         GDBusConnection *conn = NULL;
  95         GVariant *dbus_result;
  96
  97         struct tapi_resp_data *evt_cb_data = user_data;
  98         TelSimPbAccessResult_t result = TAPI_SIM_PB_SUCCESS;
  99         TelSimPbEntryInfo_t pb_entry ;
 100
 101         gint imin = 0, imax = 0, nmax = 0, tmax = 0, used = 0;
 102
 103         memset(&pb_entry, 0, sizeof(TelSimPbEntryInfo_t));
 104
 105         conn = G_DBUS_CONNECTION (source_object);
 106         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 107         CHECK_DEINIT(error);
 108
 109         if (!dbus_result) {
 110                 if (evt_cb_data->cb_fn) {
 111                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 112                 }
 113
 114                 if (error)
 115                         g_error_free(error);
 116
 117                 g_free(evt_cb_data);
 118                 return;
 119         }
 120
 121         g_variant_get (dbus_result, "(iiiiiii)",
 122                         &result,
 123                         &pb_entry.StorageFileType,
 124                         &imin,
 125                         &imax,
 126                         &nmax,
 127                         &tmax,
 128                         &used);
 129
 130         pb_entry.PbIndexMin = imin;
 131         pb_entry.PbIndexMax = imax;
 132         pb_entry.PbNumLenMax =nmax;
 133         pb_entry.PbTextLenMax = tmax;
 134         pb_entry.PbUsedCount = used;
 135
 136         if (evt_cb_data->cb_fn) {
 137                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &pb_entry, evt_cb_data->user_data);
 138         }
 139
 140         g_free(evt_cb_data);
 141 }
 142
 143 static void on_response_get_sim_pb_usim_meta_info(GObject *source_object, GAsyncResult *res, gpointer user_data)
 144 {
 145         GError *error = NULL;
 146         GDBusConnection *conn = NULL;
 147         GVariant *dbus_result;
 148         GVariant *value = NULL;
 149         GVariantIter *iter = NULL;
 150         GVariantIter *iter_row = NULL;
 151         const gchar *key = NULL;
 152         struct tapi_resp_data *evt_cb_data = user_data;
 153         TelSimPbAccessResult_t result = TAPI_SIM_PB_SUCCESS;
 154         TelSimPbCapabilityInfo_t list ;
 155         int i = 0;
 156
 157         dbg("Func Entrance");
 158         memset(&list, 0, sizeof(TelSimPbCapabilityInfo_t));
 159
 160         conn = G_DBUS_CONNECTION (source_object);
 161         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 162         CHECK_DEINIT(error);
 163
 164         if (!dbus_result) {
 165                 if (evt_cb_data->cb_fn) {
 166                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 167                 }
 168
 169                 if (error)
 170                         g_error_free(error);
 171
 172                 g_free(evt_cb_data);
 173                 return;
 174         }
 175
 176         g_variant_get(dbus_result, "(iaa{sv})", &result, &iter);
 177         list.FileTypeCount = g_variant_iter_n_children(iter);
 178
 179         i = 0;
 180         while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
 181                 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
 182                         if (!g_strcmp0(key, "field_type")) {
 183                                 list.FileTypeInfo[i].field_type = g_variant_get_int32(value);
 184                         }
 185                         if (!g_strcmp0(key, "index_max")) {
 186                                 list.FileTypeInfo[i].index_max = g_variant_get_int32(value);
 187                         }
 188                         if (!g_strcmp0(key, "text_max")) {
 189                                 list.FileTypeInfo[i].text_max = g_variant_get_int32(value);
 190                         }
 191                         if (!g_strcmp0(key, "used_count")) {
 192                                 list.FileTypeInfo[i].used_count = g_variant_get_int32(value);
 193                         }
 194                 }
 195                 i++;
 196                 g_variant_iter_free(iter_row);
 197         }
 198         g_variant_iter_free(iter);
 199
 200         if (evt_cb_data->cb_fn) {
 201                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &list, evt_cb_data->user_data);
 202         }
 203
 204         g_free(evt_cb_data);
 205 }
 206
 207 static void on_response_read_sim_pb_record(GObject *source_object, GAsyncResult *res, gpointer user_data)
 208 {
 209         GError *error = NULL;
 210         GDBusConnection *conn = NULL;
 211         GVariant *dbus_result;
 212
 213         struct tapi_resp_data *evt_cb_data = user_data;
 214         TelSimPbAccessResult_t result = TAPI_SIM_PB_SUCCESS;
 215         TelSimPbRecord_t pb_rec ;
 216
 217         gint i = 0, ni = 0;
 218         gchar *name = NULL;
 219         gchar *number = NULL;
 220         gchar *sne = NULL;
 221         gchar *anr1 = NULL;
 222         gchar *anr2 = NULL;
 223         gchar *anr3 = NULL;
 224         gchar *email1 = NULL;
 225         gchar *email2 = NULL;
 226         gchar *email3 = NULL;
 227         gchar *email4 = NULL;
 228
 229         memset(&pb_rec, 0, sizeof(TelSimPbRecord_t));
 230
 231         conn = G_DBUS_CONNECTION (source_object);
 232         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 233         CHECK_DEINIT(error);
 234
 235         if (!dbus_result) {
 236                 if (evt_cb_data->cb_fn) {
 237                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 238                 }
 239
 240                 if (error)
 241                         g_error_free(error);
 242
 243                 g_free(evt_cb_data);
 244                 return;
 245         }
 246
 247         g_variant_get (dbus_result, "(iiiisisisisisisissssi)",
 248                         &result,
 249                         &pb_rec.phonebook_type,
 250                         &i,
 251                         &ni,
 252                         &name,
 253                         &pb_rec.dcs,
 254                         &number,
 255                         &pb_rec.ton,
 256                         &sne,
 257                         &pb_rec.sne_dcs,
 258                         &anr1,
 259                         &pb_rec.anr1_ton,
 260                         &anr2,
 261                         &pb_rec.anr2_ton,
 262                         &anr3,
 263                         &pb_rec.anr3_ton,
 264                         &email1,
 265                         &email2,
 266                         &email3,
 267                         &email4,
 268                         &pb_rec.group_index);
 269
 270         pb_rec.index = i;
 271         pb_rec.next_index = ni;
 272
 273         move_str ((char *)pb_rec.name, TAPI_SIM_PB_RECORD_NAME_MAX_LEN, name);
 274         move_str ((char *)pb_rec.number, TAPI_SIM_PB_RECORD_NUMBER_MAX_LEN, number);
 275         move_str ((char *)pb_rec.sne, TAPI_SIM_PB_RECORD_NAME_MAX_LEN, sne);
 276         move_str ((char *)pb_rec.anr1, TAPI_SIM_PB_RECORD_NUMBER_MAX_LEN, anr1);
 277         move_str ((char *)pb_rec.anr2, TAPI_SIM_PB_RECORD_NUMBER_MAX_LEN, anr2);
 278         move_str ((char *)pb_rec.anr3, TAPI_SIM_PB_RECORD_NUMBER_MAX_LEN, anr3);
 279         move_str ((char *)pb_rec.email1, TAPI_SIM_PB_RECORD_EMAIL_MAX_LEN, email1);
 280         move_str ((char *)pb_rec.email2, TAPI_SIM_PB_RECORD_EMAIL_MAX_LEN, email2);
 281         move_str ((char *)pb_rec.email3, TAPI_SIM_PB_RECORD_EMAIL_MAX_LEN, email3);
 282
 283         dbg("type[%d], index[%d], next_index[%d]", pb_rec.phonebook_type,
 284                         pb_rec.index, pb_rec.next_index);
 285         dbg("name[%s], dcs[%d]", pb_rec.name, pb_rec.dcs);
 286         dbg("number[%s], ton[%d]", pb_rec.number, pb_rec.ton);
 287
 288         if (pb_rec.phonebook_type==TAPI_SIM_PB_3GSIM) {
 289                 dbg("sne[%s], sne_dcs[%d]", pb_rec.sne, pb_rec.sne_dcs);
 290                 dbg("anr1([%d][%s]),anr2([%d][%s]),anr3([%d][%s])",
 291                                 pb_rec.anr1_ton, pb_rec.anr1, pb_rec.anr2_ton, pb_rec.anr2,
 292                                 pb_rec.anr3_ton, pb_rec.anr3);
 293                 dbg("email[%s] [%s][%s][%s]", pb_rec.email1, pb_rec.email2,
 294                                 pb_rec.email3, pb_rec.email4);
 295                 dbg("group_index[%d], pb_control[%d]", pb_rec.group_index,
 296                                 pb_rec.pb_control);
 297         }
 298
 299         if (evt_cb_data->cb_fn) {
 300                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &pb_rec, evt_cb_data->user_data);
 301         }
 302
 303         g_free(evt_cb_data);
 304 }
 305
 306 static void on_response_update_sim_pb_record(GObject *source_object, GAsyncResult *res, gpointer user_data)
 307 {
 308         GError *error = NULL;
 309         GDBusConnection *conn = NULL;
 310         GVariant *dbus_result;
 311
 312         struct tapi_resp_data *evt_cb_data = user_data;
 313         TelSimPbAccessResult_t result = TAPI_SIM_PB_SUCCESS;
 314
 315         conn = G_DBUS_CONNECTION (source_object);
 316         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 317         CHECK_DEINIT(error);
 318
 319         if (!dbus_result) {
 320                 if (evt_cb_data->cb_fn) {
 321                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 322                 }
 323
 324                 if (error)
 325                         g_error_free(error);
 326
 327                 g_free(evt_cb_data);
 328                 return;
 329         }
 330
 331         g_variant_get (dbus_result, "(i)", &result);
 332
 333         if (evt_cb_data->cb_fn) {
 334                 evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
 335         }
 336
 337         g_free(evt_cb_data);
 338 }
 339
 340 static void on_response_delete_sim_pb_record(GObject *source_object, GAsyncResult *res, gpointer user_data)
 341 {
 342         GError *error = NULL;
 343         GDBusConnection *conn = NULL;
 344         GVariant *dbus_result;
 345
 346         struct tapi_resp_data *evt_cb_data = user_data;
 347         TelSimPbAccessResult_t result = TAPI_SIM_PB_SUCCESS;
 348
 349         conn = G_DBUS_CONNECTION (source_object);
 350         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 351         CHECK_DEINIT(error);
 352
 353         if (!dbus_result) {
 354                 if (evt_cb_data->cb_fn) {
 355                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 356                 }
 357
 358                 if (error)
 359                         g_error_free(error);
 360
 361                 g_free(evt_cb_data);
 362                 return;
 363         }
 364
 365         g_variant_get (dbus_result, "(i)", &result);
 366
 367         if (evt_cb_data->cb_fn) {
 368                 evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
 369         }
 370
 371         g_free(evt_cb_data);
 372 }
 373
 374 EXPORT_API int tel_get_sim_pb_init_info(TapiHandle *handle, int *init_completed, TelSimPbList_t *pb_list)
 375 {
 376         GError *gerr = NULL;
 377         GVariant *sync_gv = NULL;
 378         int init_status = 0;
 379
 380         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 381         TAPI_RET_ERR_NUM_IF_FAIL(init_completed, TAPI_API_INVALID_PTR);
 382         TAPI_RET_ERR_NUM_IF_FAIL(pb_list, TAPI_API_INVALID_PTR);
 383
 384         sync_gv = g_dbus_connection_call_sync(handle->dbus_connection, DBUS_TELEPHONY_SERVICE,
 385                         handle->path, DBUS_TELEPHONY_PB_INTERFACE, "GetInitStatus", NULL, NULL,
 386                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca, &gerr);
 387
 388         if (sync_gv) {
 389                 g_variant_get(sync_gv, "(ibbbbbb)",
 390                                 &init_status,
 391                                 &pb_list->b_fdn,
 392                                 &pb_list->b_adn,
 393                                 &pb_list->b_sdn,
 394                                 &pb_list->b_3g,
 395                                 &pb_list->b_aas,
 396                                 &pb_list->b_gas);
 397                 *init_completed = init_status;
 398         }
 399         else {
 400                 err("Operation Failed - Error: (%s)", gerr->message);
 401                 g_error_free (gerr);
 402                 return TAPI_API_OPERATION_FAILED;
 403         }
 404
 405         dbg("b_(fdn[%d] adn[%d] sdn[%d] 3g[%d] aas[%d] gas[%d])",
 406                 pb_list->b_fdn,pb_list->b_adn,pb_list->b_sdn,pb_list->b_3g,pb_list->b_aas,pb_list->b_gas);
 407
 408         return TAPI_API_SUCCESS;
 409 }
 410
 411 EXPORT_API int tel_get_sim_pb_count(TapiHandle *handle, TelSimPbType_t pb_type, tapi_response_cb callback, void *user_data)
 412 {
 413         struct tapi_resp_data *evt_cb_data = NULL;
 414         GVariant *param = NULL;
 415
 416         dbg("Func Entrance");
 417
 418         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 419         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
 420
 421         if ( (pb_type != TAPI_SIM_PB_FDN) && (pb_type != TAPI_SIM_PB_ADN) && (pb_type != TAPI_SIM_PB_SDN)
 422                         && (pb_type     != TAPI_SIM_PB_3GSIM) && (pb_type != TAPI_SIM_PB_AAS) && (pb_type != TAPI_SIM_PB_GAS))
 423                 return TAPI_API_INVALID_INPUT;
 424
 425         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 426
 427         param = g_variant_new("(i)", pb_type);
 428
 429         g_dbus_connection_call(handle->dbus_connection,
 430                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_PB_INTERFACE,
 431                         "GetCount", param, NULL,
 432                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 433                         on_response_get_sim_pb_count, evt_cb_data);
 434
 435         return TAPI_API_SUCCESS;
 436 }
 437
 438 EXPORT_API int tel_get_sim_pb_meta_info(TapiHandle *handle, TelSimPbType_t pb_type, tapi_response_cb callback, void *user_data)
 439 {
 440         struct tapi_resp_data *evt_cb_data = NULL;
 441         GVariant *param = NULL;
 442
 443         dbg("Func Entrance");
 444
 445         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 446         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
 447
 448         if ( (pb_type != TAPI_SIM_PB_FDN) && (pb_type != TAPI_SIM_PB_ADN) && (pb_type != TAPI_SIM_PB_SDN)
 449                         && (pb_type     != TAPI_SIM_PB_3GSIM) && (pb_type != TAPI_SIM_PB_AAS) && (pb_type != TAPI_SIM_PB_GAS))
 450                 return TAPI_API_INVALID_INPUT;
 451
 452         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 453
 454         param = g_variant_new("(i)", pb_type);
 455
 456         g_dbus_connection_call(handle->dbus_connection,
 457                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_PB_INTERFACE,
 458                         "GetInfo", param, NULL,
 459                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 460                         on_response_get_sim_pb_meta_info, evt_cb_data);
 461
 462         return TAPI_API_SUCCESS;
 463 }
 464
 465 EXPORT_API int tel_get_sim_pb_usim_meta_info(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 466 {
 467         struct tapi_resp_data *evt_cb_data = NULL;
 468         GVariant *param = NULL;
 469
 470         dbg("Func Entrance");
 471
 472         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 473         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
 474
 475         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 476
 477         g_dbus_connection_call(handle->dbus_connection,
 478                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_PB_INTERFACE,
 479                         "GetUsimMetaInfo", param, NULL,
 480                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 481                         on_response_get_sim_pb_usim_meta_info, evt_cb_data);
 482
 483         return TAPI_API_SUCCESS;
 484 }
 485
 486 EXPORT_API int tel_read_sim_pb_record(TapiHandle *handle, TelSimPbType_t pb_type, unsigned short index, tapi_response_cb callback, void *user_data)
 487 {
 488         struct tapi_resp_data *evt_cb_data = NULL;
 489         GVariant *param = NULL;
 490
 491         dbg("Func Entrance");
 492
 493         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 494         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
 495
 496         if (index == 0)
 497                 return TAPI_API_INVALID_INPUT;
 498
 499         if ( (pb_type != TAPI_SIM_PB_FDN) && (pb_type != TAPI_SIM_PB_ADN) && (pb_type != TAPI_SIM_PB_SDN)
 500                         && (pb_type     != TAPI_SIM_PB_3GSIM) && (pb_type != TAPI_SIM_PB_AAS) && (pb_type != TAPI_SIM_PB_GAS))
 501                 return TAPI_API_INVALID_INPUT;
 502
 503         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 504
 505         param = g_variant_new("(ii)", pb_type, index);
 506
 507         g_dbus_connection_call(handle->dbus_connection,
 508                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_PB_INTERFACE,
 509                         "ReadRecord", param, NULL,
 510                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 511                         on_response_read_sim_pb_record, evt_cb_data);
 512
 513         return TAPI_API_SUCCESS;
 514 }
 515
 516 EXPORT_API int tel_update_sim_pb_record(TapiHandle *handle, const TelSimPbRecord_t *req_data, tapi_response_cb callback, void *user_data)
 517 {
 518         struct tapi_resp_data *evt_cb_data = NULL;
 519         GVariant *param = NULL;
 520
 521         dbg("Func Entrance");
 522
 523         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 524         TAPI_RET_ERR_NUM_IF_FAIL((req_data != NULL) , TAPI_API_INVALID_PTR);
 525
 526         if (req_data->index == 0) {
 527                 return TAPI_API_INVALID_INPUT;
 528         }
 529
 530         if ((req_data->phonebook_type != TAPI_SIM_PB_FDN)
 531                         && (req_data->phonebook_type != TAPI_SIM_PB_ADN) && (req_data->phonebook_type != TAPI_SIM_PB_SDN)
 532                         && (req_data->phonebook_type != TAPI_SIM_PB_3GSIM) && (req_data->phonebook_type != TAPI_SIM_PB_AAS)
 533                         && (req_data->phonebook_type != TAPI_SIM_PB_GAS)) {
 534                 return TAPI_API_INVALID_INPUT;
 535         }
 536
 537         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 538
 539         dbg("type[%d], index[%d], next_index[%d]",req_data->phonebook_type, req_data->index, req_data->next_index);
 540         dbg("name[%s], dcs[%d]",req_data->name, req_data->dcs);
 541         dbg("number[%s], ton[%d]",req_data->number, req_data->ton);
 542
 543         if(req_data->phonebook_type == TAPI_SIM_PB_3GSIM) {
 544                 dbg("sne[%s] sne_dcs[%d]",req_data->sne, req_data->sne_dcs);
 545                 dbg("anr1([%d][%s]),anr2([%d][%s]),anr3([%d][%s])",
 546                         req_data->anr1_ton,req_data->anr1,req_data->anr2_ton,req_data->anr2,req_data->anr3_ton,req_data->anr3);
 547                 dbg("email[%s] [%s][%s][%s]",req_data->email1,req_data->email2,req_data->email3,req_data->email4);
 548                 dbg("group_index[%d], pb_control[%d]",req_data->group_index,req_data->pb_control);
 549         }
 550
 551         param = g_variant_new("(iisisisisisisissssi)",
 552                         req_data->phonebook_type,
 553                         req_data->index,
 554                         req_data->name,
 555                         req_data->dcs,
 556                         req_data->number,
 557                         req_data->ton,
 558                         req_data->sne,
 559                         req_data->sne_dcs,
 560                         req_data->anr1,
 561                         req_data->anr1_ton,
 562                         req_data->anr2,
 563                         req_data->anr2_ton,
 564                         req_data->anr3,
 565                         req_data->anr3_ton,
 566                         req_data->email1,
 567                         req_data->email2,
 568                         req_data->email3,
 569                         req_data->email4,
 570                         req_data->group_index);
 571
 572         g_dbus_connection_call(handle->dbus_connection,
 573                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_PB_INTERFACE,
 574                         "UpdateRecord", param, NULL,
 575                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 576                         on_response_update_sim_pb_record, evt_cb_data);
 577
 578         return TAPI_API_SUCCESS;
 579
 580 }
 581
 582 EXPORT_API int tel_delete_sim_pb_record(TapiHandle *handle, TelSimPbType_t pb_type, unsigned short index, tapi_response_cb callback, void *user_data)
 583 {
 584         struct tapi_resp_data *evt_cb_data = NULL;
 585         GVariant *param = NULL;
 586
 587         dbg("Func Entrance");
 588
 589         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 590
 591
 592         if (index == 0)
 593                 return TAPI_API_INVALID_INPUT;
 594
 595         if ( (pb_type != TAPI_SIM_PB_FDN) && (pb_type != TAPI_SIM_PB_ADN) && (pb_type != TAPI_SIM_PB_SDN)
 596                         && (pb_type     != TAPI_SIM_PB_3GSIM) && (pb_type != TAPI_SIM_PB_AAS) && (pb_type != TAPI_SIM_PB_GAS))
 597                 return TAPI_API_INVALID_INPUT;
 598
 599         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 600
 601         param = g_variant_new("(ii)", pb_type, index);
 602
 603         g_dbus_connection_call(handle->dbus_connection,
 604                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_PB_INTERFACE,
 605                         "DeleteRecord", param, NULL,
 606                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 607                         on_response_delete_sim_pb_record, evt_cb_data);
 608
 609         return TAPI_API_SUCCESS;
 610 }