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