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