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