server/ctsvc_server_sim.c

   1 /*
   2  * Contacts Service
   3  *
   4  * Copyright (c) 2010 - 2015 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #include <glib-object.h>
  21 #include <string.h>
  22 #include <tapi_common.h>
  23 #include <ITapiSim.h>
  24 #include <ITapiPhonebook.h>
  25 #include <TapiUtility.h>
  26 #include <vconf.h>
  27 #include <vconf-internal-telephony-keys.h>
  28
  29 #include "contacts.h"
  30
  31 #include "ctsvc_internal.h"
  32 #include "ctsvc_struct.h"
  33 #include "ctsvc_db_schema.h"
  34 #include "ctsvc_db_sqlite.h"
  35 #include "ctsvc_server_socket.h"
  36 #include "ctsvc_server_sqlite.h"
  37 #include "ctsvc_server_utils.h"
  38 #include "ctsvc_server_sim.h"
  39 #include "ctsvc_db_utils.h"
  40 #include "ctsvc_list.h"
  41 #include "ctsvc_db_access_control.h"
  42 #include "ctsvc_db_query.h"
  43
  44 /* #define CTSVC_SIM_FIELD_FULL_SUPPORT// support ANR,EMAIL2,3,NICK NAME */
  45 #define DEFAULT_ADDRESS_BOOK_ID 0
  46
  47 #define CTSVC_TAPI_SIM_PB_MAX 0xFFFF
  48
  49 #define TAPI_PB_MAX_FILE_CNT TAPI_PB_3G_PBC+1
  50
  51 #define CTSVC_2GSIM_NAME TAPI_PB_3G_NAME
  52 #define CTSVC_2GSIM_NUMBER TAPI_PB_3G_NUMBER
  53
  54 typedef struct {
  55         bool support;
  56         unsigned int index_max;
  57         unsigned int text_max;
  58         unsigned int used_count;
  59 } sim_file_s;
  60
  61 typedef struct {
  62         /* SIM slot number */
  63         int sim_slot_no;
  64
  65         /*
  66          * SIM info table id
  67          * it is used when inserting/seaching phonelog
  68          */
  69         int sim_info_id;
  70
  71         /* SIM slot id */
  72         char *cp_name;
  73
  74         /* Tapi handle to control each SIM slot */
  75         TapiHandle *handle;
  76
  77         /* SIM type */
  78         TelSimPbType_t sim_type;
  79
  80         /* Each sim file info (max index, max text length, used count) */
  81         sim_file_s file_record[TAPI_PB_MAX_FILE_CNT];
  82
  83         /* Number of Imported SIM contact*/
  84         int imported_cnt;
  85
  86         /*
  87          * Set true after read SIM meta info
  88          * in case of private : set true after reading all SIM contact and save to DB
  89          */
  90         bool initialized;
  91
  92         /*
  93          * unique info of SIM : iccid
  94          * It should be save to phone log table
  95          * in order to find which SIM is used to the call/message log
  96          */
  97         char *sim_unique_id;
  98
  99 } ctsvc_sim_info_s;
 100
 101
 102 static GSList *__ctsvc_sim_info = NULL;
 103 static void *greturn_data = NULL;
 104 static bool __ctsvc_tapi_cb = false;
 105 static bool sim_import_cancel = false;
 106
 107 static TapiHandle* __ctsvc_server_sim_get_tapi_handle(ctsvc_sim_info_s *info)
 108 {
 109         if (NULL == info->handle) {
 110                 int bReady = 0;
 111                 vconf_get_bool(VCONFKEY_TELEPHONY_READY, &bReady);
 112
 113                 if (0 == bReady) {
 114                         /* LCOV_EXCL_START */
 115                         ERR("telephony is not ready ");
 116                         return NULL;
 117                         /* LCOV_EXCL_STOP */
 118                 } else {
 119                         info->handle = tel_init(info->cp_name);
 120                         RETVM_IF(NULL == info->handle, NULL, "tel_init() Fail");
 121                 }
 122         }
 123
 124         return info->handle;
 125 }
 126
 127 static inline void __ctsvc_server_sim_set_return_data(void *data)
 128 {
 129         greturn_data = data;
 130 }
 131
 132 static inline void* __ctsvc_server_sim_get_return_data(void)
 133 {
 134         RETV_IF(NULL == greturn_data, NULL);
 135
 136         return greturn_data;
 137 }
 138
 139 static void __ctsvc_server_sim_record_destroy(sim_contact_s *record)
 140 {
 141         RET_IF(NULL == record);
 142
 143         free(record->name);
 144         free(record->number);
 145         free(record->anr1);
 146         free(record->anr2);
 147         free(record->anr3);
 148         free(record->email1);
 149         free(record->email2);
 150         free(record->email3);
 151         free(record->email4);
 152         free(record);
 153
 154         return;
 155 }
 156
 157 static sim_contact_s * __ctsvc_server_sim_record_clone(TelSimPbRecord_t *sim_record)
 158 {
 159         sim_contact_s *record = calloc(1, sizeof(sim_contact_s));
 160         if (NULL == record) {
 161                 /* LCOV_EXCL_START */
 162                 ERR("calloc() Fail");
 163                 return NULL;
 164                 /* LCOV_EXCL_STOP */
 165         }
 166
 167         record->sim_index = sim_record->index;
 168         record->name = SAFE_STRDUP((char*)sim_record->name);
 169         record->nickname = SAFE_STRDUP((char*)sim_record->sne);
 170         record->number = SAFE_STRDUP((char*)sim_record->number);
 171         record->anr1 = SAFE_STRDUP((char*)sim_record->anr1);
 172         record->anr2 = SAFE_STRDUP((char*)sim_record->anr2);
 173         record->anr3 = SAFE_STRDUP((char*)sim_record->anr3);
 174         record->email1 = SAFE_STRDUP((char*)sim_record->email1);
 175         record->email2 = SAFE_STRDUP((char*)sim_record->email2);
 176         record->email3 = SAFE_STRDUP((char*)sim_record->email3);
 177         record->email4 = SAFE_STRDUP((char*)sim_record->email4);
 178
 179         return record;
 180 }
 181
 182 static inline int __ctsvc_server_sim_record_add_num(contacts_record_h *record, char *number)
 183 {
 184         int ret;
 185
 186         RETVM_IF(NULL == number, CONTACTS_ERROR_INVALID_PARAMETER, "invalid number");
 187
 188         ret = contacts_record_create(_contacts_number._uri, record);
 189         RETVM_IF(ret < CONTACTS_ERROR_NONE, ret, "contacts_record_create() Fail(%d)", ret);
 190         ret = contacts_record_set_str(*record, _contacts_number.number, number);
 191         RETVM_IF(ret < CONTACTS_ERROR_NONE, ret, "contacts_record_set_str() Fail(%d)", ret);
 192         ret = contacts_record_set_int(*record, _contacts_number.type, CONTACTS_NUMBER_TYPE_OTHER);
 193         RETVM_IF(ret < CONTACTS_ERROR_NONE, ret, "contacts_record_set_int() Fail(%d)", ret);
 194
 195         return ret;
 196 }
 197
 198 static inline int __ctsvc_server_sim_record_add_email(contacts_record_h *record, char *email)
 199 {
 200         int ret;
 201
 202         RETVM_IF(NULL == email, CONTACTS_ERROR_INVALID_PARAMETER, "invalid email");
 203
 204         ret = contacts_record_create(_contacts_email._uri, record);
 205         RETVM_IF(ret < CONTACTS_ERROR_NONE, ret, "contacts_record_create() Fail(%d)", ret);
 206         ret = contacts_record_set_str(*record, _contacts_email.email, email);
 207         RETVM_IF(ret < CONTACTS_ERROR_NONE, ret, "contacts_record_set_str() Fail(%d)", ret);
 208         ret = contacts_record_set_int(*record, _contacts_email.type, CONTACTS_EMAIL_TYPE_OTHER);
 209         RETVM_IF(ret < CONTACTS_ERROR_NONE, ret, "contacts_record_set_int() Fail(%d)", ret);
 210
 211         return ret;
 212 }
 213
 214 static int __ctsvc_server_sim_ctsvc_record_clone(sim_contact_s *record,
 215                 int addressbook_id, contacts_record_h *contact)
 216 {
 217         CTS_FN_CALL;
 218         int ret;
 219         char sim_id[20] = {0};
 220         contacts_record_h name = NULL;
 221         contacts_record_h number = NULL;
 222         contacts_record_h email = NULL;
 223
 224         RETV_IF(NULL == contact, CONTACTS_ERROR_INVALID_PARAMETER);
 225         *contact = NULL;
 226         RETV_IF(NULL == record, CONTACTS_ERROR_INVALID_PARAMETER);
 227         RETVM_IF(record->sim_index <= 0, CONTACTS_ERROR_INVALID_PARAMETER, "The index(%d) is invalid", record->sim_index);
 228
 229         DBG("insert record->sim_index %d", record->sim_index);
 230
 231         ret = contacts_record_create(_contacts_contact._uri, contact);
 232         RETVM_IF(CONTACTS_ERROR_NONE != ret, ret, "contacts_record_create Fail(%d)", ret);
 233         snprintf(sim_id, sizeof(sim_id), "%d", record->sim_index);
 234         contacts_record_set_str(*contact, _contacts_contact.uid, sim_id);
 235
 236         if (record->name) {
 237                 contacts_record_create(_contacts_name._uri, &name);
 238                 if (name) {
 239                         contacts_record_set_str(name, _contacts_name.first, (char *)record->name);
 240                         contacts_record_add_child_record(*contact, _contacts_contact.name, name);
 241                 }
 242         }
 243
 244 #ifdef CTSVC_SIM_FIELD_FULL_SUPPORT
 245         contacts_record_h nick = NULL;
 246         if (record->nickname) {
 247                 contacts_record_create(_contacts_nickname._uri, &nick);
 248                 if (nick) {
 249                         contacts_record_set_str(nick, _contacts_nickname.name, (char *)record->nickname);
 250                         contacts_record_add_child_record(*contact, _contacts_contact.nickname, nick);
 251                 }
 252         }
 253 #endif /* CTSVC_SIM_FIELD_FULL_SUPPORT */
 254
 255         ret = __ctsvc_server_sim_record_add_num(&number, (char *)record->number);
 256         if (CONTACTS_ERROR_NONE == ret)
 257                 contacts_record_add_child_record(*contact, _contacts_contact.number, number);
 258
 259 #ifdef CTSVC_SIM_FIELD_FULL_SUPPORT
 260         ret = __ctsvc_server_sim_record_add_num(&number, (char *)record->anr1);
 261         if (CONTACTS_ERROR_NONE == ret)
 262                 contacts_record_add_child_record(*contact, _contacts_contact.number, number);
 263
 264         ret = __ctsvc_server_sim_record_add_num(&number, (char *)record->anr2);
 265         if (CONTACTS_ERROR_NONE == ret)
 266                 contacts_record_add_child_record(*contact, _contacts_contact.number, number);
 267
 268         ret = __ctsvc_server_sim_record_add_num(&number, (char *)record->anr3);
 269         if (CONTACTS_ERROR_NONE == ret)
 270                 contacts_record_add_child_record(*contact, _contacts_contact.number, number);
 271 #endif /* CTSVC_SIM_FIELD_FULL_SUPPORT */
 272
 273         ret = __ctsvc_server_sim_record_add_email(&email, (char *)record->email1);
 274         if (CONTACTS_ERROR_NONE == ret)
 275                 contacts_record_add_child_record(*contact, _contacts_contact.email, email);
 276
 277 #ifdef CTSVC_SIM_FIELD_FULL_SUPPORT
 278         ret = __ctsvc_server_sim_record_add_email(&email, (char *)record->email2);
 279         if (CONTACTS_ERROR_NONE == ret)
 280                 contacts_record_add_child_record(*contact, _contacts_contact.email, email);
 281
 282         ret = __ctsvc_server_sim_record_add_email(&email, (char *)record->email3);
 283         if (CONTACTS_ERROR_NONE == ret)
 284                 contacts_record_add_child_record(*contact, _contacts_contact.email, email);
 285
 286         ret = __ctsvc_server_sim_record_add_email(&email, (char *)record->email4);
 287         if (CONTACTS_ERROR_NONE == ret)
 288                 contacts_record_add_child_record(*contact, _contacts_contact.email, email);
 289 #endif /* CTSVC_SIM_FIELD_FULL_SUPPORT */
 290
 291         contacts_record_set_int(*contact, _contacts_contact.address_book_id, addressbook_id);
 292
 293         return ret;
 294 }
 295
 296 static ctsvc_sim_info_s* __ctsvc_server_sim_get_info_by_tapi_handle(TapiHandle *handle)
 297 {
 298         GSList *cursor = NULL;
 299         for (cursor = __ctsvc_sim_info; cursor; cursor = cursor->next) {
 300                 ctsvc_sim_info_s *info = cursor->data;
 301                 if (info->handle == handle)
 302                         return info;
 303         }
 304         return NULL;
 305 }
 306
 307 static ctsvc_sim_info_s* __ctsvc_server_sim_get_info_by_sim_slot_no(int slot_no)
 308 {
 309         GSList *cursor = NULL;
 310
 311         if (slot_no < 0)
 312                 return NULL;
 313
 314         for (cursor = __ctsvc_sim_info; cursor; cursor = cursor->next) {
 315                 ctsvc_sim_info_s *info = cursor->data;
 316                 if (info->sim_slot_no == slot_no) {
 317                         if (NULL == __ctsvc_server_sim_get_tapi_handle(info))
 318                                 return NULL;
 319                         return info;
 320                 }
 321         }
 322         return NULL;
 323 }
 324
 325 int ctsvc_server_sim_get_info_id_by_sim_slot_no(int slot_no)
 326 {
 327         GSList *cursor = NULL;
 328
 329         if (slot_no < 0)
 330                 return -1;
 331
 332         for (cursor = __ctsvc_sim_info; cursor; cursor = cursor->next) {
 333                 ctsvc_sim_info_s *info = cursor->data;
 334                 if (info->sim_slot_no == slot_no) {
 335                         if (NULL == __ctsvc_server_sim_get_tapi_handle(info))
 336                                 return -1;
 337                         return info->sim_info_id;
 338                 }
 339         }
 340         return -1;
 341 }
 342
 343 int ctsvc_server_sim_get_sim_slot_no_by_info_id(int sim_info_id)
 344 {
 345         GSList *cursor = NULL;
 346         for (cursor = __ctsvc_sim_info; cursor; cursor = cursor->next) {
 347                 ctsvc_sim_info_s *info = cursor->data;
 348                 if (info->sim_info_id == sim_info_id) {
 349                         if (NULL == __ctsvc_server_sim_get_tapi_handle(info))
 350                                 return -1;
 351                         return info->sim_slot_no;
 352                 }
 353         }
 354         return -1;
 355 }
 356
 357 static void __ctsvc_server_sim_init_import_info(ctsvc_sim_info_s *info)
 358 {
 359         RET_IF(NULL == info);
 360
 361         info->imported_cnt = 0;
 362 }
 363
 364 static int __ctsvc_server_sim_insert_record_to_db(sim_contact_s *record)
 365 {
 366         CTS_FN_CALL;
 367         int ret = 0;
 368         contacts_record_h contact = NULL;
 369
 370         ret = __ctsvc_server_sim_ctsvc_record_clone(record, DEFAULT_ADDRESS_BOOK_ID, &contact);
 371         if (CONTACTS_ERROR_NONE != ret) {
 372                 /* LCOV_EXCL_START */
 373                 ERR("__ctsvc_server_sim_ctsvc_record_clone() Fail(%d)", ret);
 374                 return CONTACTS_ERROR_INTERNAL;
 375                 /* LCOV_EXCL_STOP */
 376         }
 377
 378         ret = ctsvc_db_insert_record(contact, NULL);
 379         contacts_record_destroy(contact, true);
 380         if (CONTACTS_ERROR_NONE != ret) {
 381                 /* LCOV_EXCL_START */
 382                 ERR("ctsvc_db_insert_record() Fail(%d)", ret);
 383                 return ret;
 384                 /* LCOV_EXCL_STOP */
 385         }
 386
 387         return CONTACTS_ERROR_NONE;
 388 }
 389
 390 static void __ctsvc_server_sim_import_contact_cb(TapiHandle *handle, int result, void *data, void *user_data)
 391 {
 392         CTS_FN_CALL;
 393         int ret = 0;
 394         TelSimPbAccessResult_t access_rt = result;
 395         TelSimPbRecord_t *sim_info = data;
 396         sim_contact_s *record = NULL;
 397         ctsvc_sim_info_s *info;
 398
 399         if (NULL == sim_info) {
 400                 /* LCOV_EXCL_START */
 401                 ERR("sim_info is NULL, result = %d", access_rt);
 402                 ret = ctsvc_server_socket_return(__ctsvc_server_sim_get_return_data(), CONTACTS_ERROR_SYSTEM, 0, NULL);
 403                 WARN_IF(CONTACTS_ERROR_NONE != ret, "ctsvc_server_socket_return() Fail(%d)", ret);
 404                 __ctsvc_server_sim_set_return_data(NULL);
 405                 return;
 406                 /* LCOV_EXCL_STOP */
 407         }
 408
 409         info = __ctsvc_server_sim_get_info_by_tapi_handle(handle);
 410         if (NULL == info) {
 411                 /* LCOV_EXCL_START */
 412                 ERR("__ctsvc_server_sim_get_info_by_tapi_handle() Fail");
 413                 ret = ctsvc_server_socket_return(__ctsvc_server_sim_get_return_data(), CONTACTS_ERROR_INTERNAL, 0, NULL);
 414                 WARN_IF(CONTACTS_ERROR_NONE != ret, "ctsvc_server_socket_return() Fail(%d)", ret);
 415                 __ctsvc_server_sim_set_return_data(NULL);
 416                 return;
 417                 /* LCOV_EXCL_STOP */
 418         }
 419
 420         if (sim_import_cancel) {
 421                 DBG("SIM contacts import is canceled");
 422                 ret = ctsvc_server_socket_return(__ctsvc_server_sim_get_return_data(), CONTACTS_ERROR_NONE, 0, NULL);
 423                 WARN_IF(CONTACTS_ERROR_NONE != ret, "ctsvc_server_socket_return() Fail(%d)", ret);
 424                 __ctsvc_server_sim_init_import_info(info);
 425                 __ctsvc_server_sim_set_return_data(NULL);
 426                 sim_import_cancel = false;
 427                 return;
 428         }
 429
 430         if (TAPI_SIM_PB_INVALID_INDEX == access_rt) {
 431                 int start_index = 0;
 432                 if (user_data)
 433                         start_index = (int)user_data;
 434                 DBG("TAPI_SIM_PB_INVALID_INDEX : start_index = %d", start_index);
 435                 start_index++;
 436                 if (info->file_record[TAPI_PB_3G_NAME].index_max < start_index) {
 437                         /* LCOV_EXCL_START */
 438                         ERR("start_index is invalid start_index = %d, total = %d", start_index,
 439                                         info->file_record[TAPI_PB_3G_NAME].index_max);
 440                         ret = ctsvc_server_socket_return(__ctsvc_server_sim_get_return_data(), CONTACTS_ERROR_INTERNAL, 0, NULL);
 441                         WARN_IF(CONTACTS_ERROR_NONE != ret, "ctsvc_server_socket_return() Fail(%d)", ret);
 442                         __ctsvc_server_sim_init_import_info(info);
 443                         __ctsvc_server_sim_set_return_data(NULL);
 444                         return;
 445                         /* LCOV_EXCL_STOP */
 446                 }
 447                 ret = tel_read_sim_pb_record(handle, info->sim_type, start_index,
 448                                 __ctsvc_server_sim_import_contact_cb, (void*)start_index);
 449                 if (TAPI_API_SUCCESS != ret) {
 450                         /* LCOV_EXCL_START */
 451                         ERR("SIM phonebook access Fail(%d) start_indext(%d)", access_rt, start_index);
 452                         ret = ctsvc_server_socket_return(__ctsvc_server_sim_get_return_data(), CONTACTS_ERROR_SYSTEM, 0, NULL);
 453                         WARN_IF(CONTACTS_ERROR_NONE != ret, "ctsvc_server_socket_return() Fail(%d)", ret);
 454                         __ctsvc_server_sim_init_import_info(info);
 455                         __ctsvc_server_sim_set_return_data(NULL);
 456                         return;
 457                         /* LCOV_EXCL_STOP */
 458                 }
 459                 return;
 460         }
 461
 462         if (TAPI_SIM_PB_SUCCESS != access_rt) {
 463                 /* LCOV_EXCL_START */
 464                 ERR("SIM phonebook access Fail(%d)", access_rt);
 465                 ret = ctsvc_server_socket_return(__ctsvc_server_sim_get_return_data(), CONTACTS_ERROR_SYSTEM, 0, NULL);
 466                 WARN_IF(CONTACTS_ERROR_NONE != ret, "ctsvc_server_socket_return() Fail(%d)", ret);
 467                 __ctsvc_server_sim_init_import_info(info);
 468                 __ctsvc_server_sim_set_return_data(NULL);
 469                 return;
 470                 /* LCOV_EXCL_STOP */
 471         }
 472
 473         switch (sim_info->phonebook_type) {
 474         case TAPI_SIM_PB_ADN:
 475         case TAPI_SIM_PB_3GSIM:
 476                 record = __ctsvc_server_sim_record_clone(sim_info);
 477                 ret = __ctsvc_server_sim_insert_record_to_db(record);
 478                 __ctsvc_server_sim_record_destroy(record);
 479                 if (CONTACTS_ERROR_NONE != ret)
 480                         WARN("__ctsvc_server_sim_insert_record_to_db() Fail(%d)", ret);
 481                 else
 482                         info->imported_cnt++;
 483                 ctsvc_server_socket_invoke_cb(__ctsvc_server_sim_get_return_data(),
 484                                 info->file_record[TAPI_PB_3G_NAME].used_count, info->imported_cnt);
 485                 break;
 486         case TAPI_SIM_PB_FDN:
 487         case TAPI_SIM_PB_SDN:
 488         default:
 489                 /* LCOV_EXCL_START */
 490                 ERR("Unknown storage type(%d)", sim_info->phonebook_type);
 491                 ret = ctsvc_server_socket_return(__ctsvc_server_sim_get_return_data(), CONTACTS_ERROR_SYSTEM, 0, NULL);
 492                 WARN_IF(CONTACTS_ERROR_NONE != ret, "ctsvc_server_socket_return() Fail(%d)", ret);
 493                 __ctsvc_server_sim_init_import_info(info);
 494                 __ctsvc_server_sim_set_return_data(NULL);
 495                 return;
 496                 /* LCOV_EXCL_STOP */
 497         }
 498
 499         if (sim_info->next_index && CTSVC_TAPI_SIM_PB_MAX != sim_info->next_index) {
 500                 DBG("NextIndex = %d", sim_info->next_index);
 501                 ret = tel_read_sim_pb_record(__ctsvc_server_sim_get_tapi_handle(info), sim_info->phonebook_type,
 502                                 sim_info->next_index, __ctsvc_server_sim_import_contact_cb, NULL);
 503
 504                 if (TAPI_API_SUCCESS != ret) {
 505                         /* LCOV_EXCL_START */
 506                         ERR("tel_read_sim_pb_record() Fail(%d)", ret);
 507                         ret = ctsvc_server_socket_return(__ctsvc_server_sim_get_return_data(), CONTACTS_ERROR_SYSTEM, 0, NULL);
 508                         WARN_IF(CONTACTS_ERROR_NONE != ret, "ctsvc_server_socket_return() Fail(%d)", ret);
 509                         __ctsvc_server_sim_init_import_info(info);
 510                         __ctsvc_server_sim_set_return_data(NULL);
 511                         return;
 512                         /* LCOV_EXCL_STOP */
 513                 }
 514         } else {
 515                 if (info->file_record[TAPI_PB_3G_NAME].used_count == info->imported_cnt) {
 516                         ret = ctsvc_server_socket_return(__ctsvc_server_sim_get_return_data(), CONTACTS_ERROR_NONE, 0, NULL);
 517                 } else {
 518                         ERR("ctsvc_server_sim_import_contact() Fail(expectd %d but got %d)", info->file_record[TAPI_PB_3G_NAME].used_count, info->imported_cnt);
 519                         ret = ctsvc_server_socket_return(__ctsvc_server_sim_get_return_data(), CONTACTS_ERROR_SYSTEM, 0, NULL);
 520                 }
 521                 WARN_IF(CONTACTS_ERROR_NONE != ret, "ctsvc_server_socket_return() Fail(%d)", ret);
 522                 __ctsvc_server_sim_init_import_info(info);
 523                 __ctsvc_server_sim_set_return_data(NULL);
 524         }
 525 }
 526
 527 int ctsvc_server_sim_import_contact(void *data, int sim_slot_no)
 528 {
 529         CTS_FN_CALL;
 530         int ret = TAPI_API_SUCCESS;
 531         ctsvc_sim_info_s *info;
 532         unsigned int sim_slot_cnt = g_slist_length(__ctsvc_sim_info);
 533
 534         RETV_IF(sim_slot_cnt <= sim_slot_no, CONTACTS_ERROR_INVALID_PARAMETER);
 535
 536         info = __ctsvc_server_sim_get_info_by_sim_slot_no(sim_slot_no);
 537         RETV_IF(NULL == info, CONTACTS_ERROR_SYSTEM);
 538         RETV_IF(false == info->initialized, CONTACTS_ERROR_NO_DATA);
 539         RETVM_IF(__ctsvc_server_sim_get_return_data(), CONTACTS_ERROR_SYSTEM,
 540                         "Server is already processing with sim");
 541
 542         __ctsvc_server_sim_set_return_data(data);
 543
 544         if (0 == info->file_record[TAPI_PB_3G_NAME].used_count) {
 545                 ret = ctsvc_server_socket_return(__ctsvc_server_sim_get_return_data(), CONTACTS_ERROR_NO_DATA, 0, NULL);
 546                 WARN_IF(CONTACTS_ERROR_NONE != ret, "helper_socket_return() Fail(%d)", ret);
 547                 __ctsvc_server_sim_set_return_data(NULL);
 548                 return ret;
 549         }
 550
 551         ret = tel_read_sim_pb_record(__ctsvc_server_sim_get_tapi_handle(info), info->sim_type, 1,
 552                         __ctsvc_server_sim_import_contact_cb, NULL);
 553         if (TAPI_API_SUCCESS != ret) {
 554                 /* LCOV_EXCL_START */
 555                 ERR("tel_read_sim_pb_record = %d", ret);
 556                 __ctsvc_server_sim_set_return_data(NULL);
 557                 return CONTACTS_ERROR_SYSTEM;
 558                 /* LCOV_EXCL_STOP */
 559         }
 560
 561         return CONTACTS_ERROR_NONE;
 562 }
 563
 564 void ctsvc_server_sim_cancel_import()
 565 {
 566         sim_import_cancel = true;
 567 }
 568
 569 int ctsvc_server_socket_get_sim_init_status(void *data, int sim_slot_no)
 570 {
 571         CTS_FN_CALL;
 572         ctsvc_sim_info_s *info;
 573         unsigned int sim_slot_cnt = g_slist_length(__ctsvc_sim_info);
 574
 575         RETV_IF(sim_slot_cnt <= sim_slot_no, CONTACTS_ERROR_INVALID_PARAMETER);
 576
 577         info = __ctsvc_server_sim_get_info_by_sim_slot_no(sim_slot_no);
 578         RETVM_IF(NULL == info, CONTACTS_ERROR_SYSTEM, "sim init is not completed");
 579         return ctsvc_server_socket_return_sim_int(data, (int)(info->initialized));
 580 }
 581
 582 static void __ctsvc_server_sim_sdn_read_cb(TapiHandle *handle, int result, void *data, void *user_data)
 583 {
 584         CTS_FN_CALL;
 585         int ret = 0;
 586         TelSimPbAccessResult_t access_rt = result;
 587         TelSimPbRecord_t *sim_info = data;
 588         ctsvc_sim_info_s *info = (ctsvc_sim_info_s*)user_data;
 589
 590         RET_IF(NULL == sim_info);
 591
 592         if (TAPI_SIM_PB_SUCCESS != access_rt) {
 593                 if (TAPI_SIM_PB_SDN == sim_info->phonebook_type &&
 594                                 TAPI_SIM_PB_INVALID_INDEX == access_rt) {
 595                         DBG("Index = %d", sim_info->index);
 596                         ret = tel_read_sim_pb_record(handle, sim_info->phonebook_type, sim_info->index+1,
 597                                         __ctsvc_server_sim_sdn_read_cb, info);
 598                         RETM_IF(TAPI_API_SUCCESS != ret,  "tel_read_sim_pb_record() Fail(%d)", ret);
 599                 }
 600                 /* LCOV_EXCL_START */
 601                 ERR("SIM phonebook access Fail(%d)", access_rt);
 602                 ctsvc_server_trim_memory();
 603                 return;
 604                 /* LCOV_EXCL_STOP */
 605         }
 606
 607         switch (sim_info->phonebook_type) {
 608         case TAPI_SIM_PB_SDN:
 609                 ret = ctsvc_server_insert_sdn_contact((char *)sim_info->name, (char *)sim_info->number, info->sim_slot_no);
 610                 WARN_IF(CONTACTS_ERROR_NONE != ret, "ctsvc_server_insert_sdn_contact() Fail(%d)", ret);
 611                 break;
 612         case TAPI_SIM_PB_ADN:
 613         case TAPI_SIM_PB_3GSIM:
 614         case TAPI_SIM_PB_FDN:
 615         default:
 616                 /* LCOV_EXCL_START */
 617                 ERR("Not SDN type(%d)", sim_info->phonebook_type);
 618                 ctsvc_server_trim_memory();
 619                 return;
 620                 /* LCOV_EXCL_STOP */
 621         }
 622
 623         if (sim_info->next_index && CTSVC_TAPI_SIM_PB_MAX != sim_info->next_index) {
 624                 DBG("NextIndex = %d", sim_info->next_index);
 625                 ret = tel_read_sim_pb_record(handle, sim_info->phonebook_type, sim_info->next_index,
 626                                 __ctsvc_server_sim_sdn_read_cb, info);
 627                 if (TAPI_API_SUCCESS != ret) {
 628                         /* LCOV_EXCL_START */
 629                         ERR("tel_read_sim_pb_record() Fail(%d)", ret);
 630                         ctsvc_server_trim_memory();
 631                         return;
 632                         /* LCOV_EXCL_STOP */
 633                 }
 634         } else {
 635                 ctsvc_server_trim_memory();
 636         }
 637 }
 638
 639 static void __ctsvc_server_sim_sdn_count_cb(TapiHandle *handle, int result, void *data, void *user_data)
 640 {
 641         CTS_FN_CALL;
 642         int ret = 0;
 643         TelSimPbAccessResult_t access_rt = result;
 644         TelSimPbStorageInfo_t *ps = data;
 645         ctsvc_sim_info_s *info = (ctsvc_sim_info_s*)user_data;
 646
 647         RETM_IF(TAPI_SIM_PB_SUCCESS != access_rt, "TelSimPbAccessResult:%d", access_rt);
 648         RETM_IF(NULL == ps, "ps is NULL. TelSimPbAccessResult:%d", access_rt);
 649
 650         if (0 < ps->UsedRecordCount) {
 651                 ret = tel_read_sim_pb_record(info->handle, TAPI_SIM_PB_SDN, 1, __ctsvc_server_sim_sdn_read_cb, info);
 652                 if (TAPI_API_SUCCESS != ret) {
 653                         /* LCOV_EXCL_START */
 654                         ERR("tel_read_sim_pb_record() Fail(%d)", ret);
 655                         ctsvc_server_trim_memory();
 656                         return;
 657                         /* LCOV_EXCL_STOP */
 658                 }
 659         } else {
 660                 /* LCOV_EXCL_START */
 661                 ERR("ps->UsedRecordCount:0. No SDN!!!!");
 662                 /* LCOV_EXCL_STOP */
 663         }
 664         ctsvc_server_trim_memory();
 665 }
 666
 667 static int __ctsvc_server_sim_sdn_read(ctsvc_sim_info_s *info)
 668 {
 669         CTS_FN_CALL;
 670         int ret;
 671         int card_changed = 0;
 672         TelSimCardStatus_t sim_status;
 673
 674         RETVM_IF(__ctsvc_server_sim_get_return_data(), CONTACTS_ERROR_INTERNAL,
 675                         "Server is already processing with sim");
 676
 677         ret = tel_get_sim_init_info(info->handle, &sim_status, &card_changed);
 678         if (TAPI_API_SUCCESS != ret) {
 679                 /* LCOV_EXCL_START */
 680                 ERR("tel_get_sim_init_info() Fail(%d)", ret);
 681                 DBG("sim_status = %d, card_changed = %d", sim_status, card_changed);
 682                 ctsvc_server_trim_memory();
 683                 return CONTACTS_ERROR_SYSTEM;
 684                 /* LCOV_EXCL_STOP */
 685         }
 686
 687         if (TAPI_SIM_STATUS_CARD_NOT_PRESENT == sim_status ||
 688                         TAPI_SIM_STATUS_CARD_REMOVED == sim_status) {
 689                 ret = ctsvc_server_delete_sdn_contact(info->sim_slot_no);
 690                 if (CONTACTS_ERROR_NONE != ret) {
 691                         /* LCOV_EXCL_START */
 692                         ERR("ctsvc_server_delete_sdn_contact() Fail(%d)", ret);
 693                         ctsvc_server_trim_memory();
 694                         return ret;
 695                         /* LCOV_EXCL_STOP */
 696                 }
 697         } else if (TAPI_SIM_STATUS_SIM_INIT_COMPLETED == sim_status) {
 698                 ret = ctsvc_server_delete_sdn_contact(info->sim_slot_no);
 699                 if (CONTACTS_ERROR_NONE != ret) {
 700                         /* LCOV_EXCL_START */
 701                         ERR("ctsvc_server_delete_sdn_contact() Fail(%d)", ret);
 702                         ctsvc_server_trim_memory();
 703                         return ret;
 704                         /* LCOV_EXCL_STOP */
 705                 }
 706
 707                 ret = tel_get_sim_pb_count(info->handle, TAPI_SIM_PB_SDN, __ctsvc_server_sim_sdn_count_cb, info);
 708                 if (TAPI_API_SUCCESS != ret) {
 709                         /* LCOV_EXCL_START */
 710                         ERR("tel_get_sim_pb_meta_info() Fail(%d)", ret);
 711                         ctsvc_server_trim_memory();
 712                         return CONTACTS_ERROR_SYSTEM;
 713                         /* LCOV_EXCL_STOP */
 714                 }
 715         } else {
 716                 /* LCOV_EXCL_START */
 717                 ERR("sim_status Fail(%d)", sim_status);
 718                 return CONTACTS_ERROR_SYSTEM;
 719                 /* LCOV_EXCL_STOP */
 720         }
 721
 722         return CONTACTS_ERROR_NONE;
 723 }
 724
 725 static void __ctsvc_server_sim_get_meta_info_cb(TapiHandle *handle, int result, void *data, void *user_data)
 726 {
 727         CTS_FN_CALL;
 728         int ret = 0;
 729         int i = 0;
 730         int type = TAPI_PB_3G_NAME;
 731         TelSimPbAccessResult_t access_rt = result;
 732         ctsvc_sim_info_s *info = (ctsvc_sim_info_s*)user_data;
 733
 734         DBG("sim slot id :%d, sim_type = %d", info->sim_slot_no, info->sim_type);
 735         if (TAPI_SIM_PB_3GSIM == info->sim_type) {
 736                 TelSimPbCapabilityInfo_t *capa = data;
 737                 RETM_IF(NULL == capa, "capa is NULL result =%d", access_rt);
 738
 739                 for (i = 0; i < capa->FileTypeCount; i++) {
 740                         type = capa->FileTypeInfo[i].field_type;
 741
 742                         info->file_record[type].support = true;
 743                         info->file_record[type].index_max = capa->FileTypeInfo[i].index_max;
 744                         info->file_record[type].text_max = capa->FileTypeInfo[i].text_max;
 745                         info->file_record[type].used_count = capa->FileTypeInfo[i].used_count;
 746
 747                         INFO(" field_type[%d] : index_max(%d), text_max(%d), used_count(%d)", type,
 748                                         info->file_record[type].index_max,
 749                                         info->file_record[type].text_max,
 750                                         info->file_record[type].used_count);
 751                 }
 752         } else if (TAPI_SIM_PB_ADN == info->sim_type) {
 753                 TelSimPbEntryInfo_t *pe = data;
 754                 RETM_IF(NULL == pe, "pe is NULL result =%d", access_rt);
 755
 756                 info->file_record[CTSVC_2GSIM_NAME].support = true;
 757                 info->file_record[CTSVC_2GSIM_NAME].index_max = pe->PbIndexMax;
 758                 info->file_record[CTSVC_2GSIM_NAME].text_max = pe->PbTextLenMax;
 759                 info->file_record[CTSVC_2GSIM_NAME].used_count = pe->PbUsedCount;
 760                 DBG(" CTSVC_2GSIM_NAME : index_max(%d), text_max(%d), used_count(%d)",
 761                                 pe->PbIndexMax, pe->PbTextLenMax, pe->PbUsedCount);
 762
 763                 info->file_record[CTSVC_2GSIM_NUMBER].support = true;
 764                 info->file_record[CTSVC_2GSIM_NUMBER].index_max = pe->PbIndexMax;
 765                 info->file_record[CTSVC_2GSIM_NUMBER].text_max = pe->PbNumLenMax;
 766                 info->file_record[CTSVC_2GSIM_NUMBER].used_count = pe->PbUsedCount;
 767                 DBG(" CTSVC_2GSIM_NUMBER : index_max(%d), text_max(%d), used_count(%d)",
 768                                 pe->PbIndexMax, pe->PbNumLenMax, pe->PbUsedCount);
 769
 770                 INFO(" field_type[%d] : index_max(%d), text_max(%d), used_count(%d)", CTSVC_2GSIM_NAME,
 771                                 info->file_record[CTSVC_2GSIM_NAME].index_max,
 772                                 info->file_record[CTSVC_2GSIM_NAME].text_max,
 773                                 info->file_record[CTSVC_2GSIM_NAME].used_count);
 774         } else {
 775                 /* LCOV_EXCL_START */
 776                 ERR("sim_type [%d]error ", info->sim_type);
 777                 return;
 778                 /* LCOV_EXCL_STOP */
 779         }
 780
 781         if (false == info->initialized) {
 782                 info->initialized = true;
 783                 ret = __ctsvc_server_sim_sdn_read(info);
 784                 WARN_IF(CONTACTS_ERROR_NONE != ret, "__ctsvc_server_sim_sdn_read() Fail(%d)", ret);
 785         }
 786 }
 787
 788 static void __ctsvc_server_sim_get_iccid_cb(TapiHandle *handle, int result, void *data,
 789                 void *user_data)
 790 {
 791         TelSimAccessResult_t access_rt = result;
 792         TelSimIccIdInfo_t *iccid = data;
 793         ctsvc_sim_info_s *info = user_data;
 794         int ret;
 795         int id;
 796
 797         RETM_IF(TAPI_SIM_ACCESS_SUCCESS != access_rt, "tel_get_sim_iccid Fail(%d)", access_rt);
 798
 799         DBG("%d, %s", iccid->icc_length, iccid->icc_num);
 800
 801         info->sim_unique_id = strdup(iccid->icc_num);
 802
 803         ret = ctsvc_server_get_sim_id(info->sim_unique_id, &id);
 804         if (CONTACTS_ERROR_NONE == ret)
 805                 info->sim_info_id = id;
 806 }
 807
 808 static int __ctsvc_server_sim_get_type_and_iccid(ctsvc_sim_info_s *info)
 809 {
 810         CTS_FN_CALL;
 811         int ret;
 812         TelSimCardType_t cardtype = TAPI_SIM_PB_UNKNOWNN;
 813
 814         /* get sim_type */
 815         ret = tel_get_sim_type(info->handle, &cardtype);
 816         RETVM_IF(TAPI_API_SUCCESS != ret, CONTACTS_ERROR_SYSTEM, "tel_get_sim_type Fail(%d)slot no(%d)", ret, info->sim_slot_no);
 817         if (TAPI_SIM_CARD_TYPE_USIM == cardtype) {
 818                 info->sim_type = TAPI_SIM_PB_3GSIM;
 819         } else if (TAPI_SIM_CARD_TYPE_GSM == cardtype) {
 820                 info->sim_type = TAPI_SIM_PB_ADN;
 821         } else {
 822                 /* LCOV_EXCL_START */
 823                 ERR("cardtype(%d)is invalid!!!", cardtype);
 824                 return CONTACTS_ERROR_SYSTEM;
 825                 /* LCOV_EXCL_STOP */
 826         }
 827
 828         /* set iccid : unique info of SIM */
 829         ret = tel_get_sim_iccid(info->handle, __ctsvc_server_sim_get_iccid_cb, info);
 830         RETVM_IF(TAPI_API_SUCCESS != ret, CONTACTS_ERROR_SYSTEM, "tel_get_sim_iccid Fail(%d)", ret);
 831
 832         return CONTACTS_ERROR_NONE;
 833 }
 834
 835 static int __ctsvc_server_sim_init_meta_info(ctsvc_sim_info_s *info)
 836 {
 837         int ret = TAPI_API_SUCCESS;
 838         int err = CONTACTS_ERROR_NONE;
 839
 840         RETV_IF(NULL == info, CONTACTS_ERROR_INVALID_PARAMETER);
 841
 842         if (TAPI_SIM_PB_UNKNOWNN == info->sim_type) {
 843                 err = __ctsvc_server_sim_get_type_and_iccid(info);
 844                 WARN_IF(CONTACTS_ERROR_NONE != err, "__ctsvc_server_sim_get_type_and_iccid() Fail(%d)", err);
 845         }
 846
 847         if (TAPI_SIM_PB_3GSIM == info->sim_type) {
 848                 ret = tel_get_sim_pb_usim_meta_info(info->handle, __ctsvc_server_sim_get_meta_info_cb, info);
 849         } else if (TAPI_SIM_PB_ADN == info->sim_type) {
 850                 ret = tel_get_sim_pb_meta_info(info->handle, info->sim_type, __ctsvc_server_sim_get_meta_info_cb, info);
 851         } else {
 852                 /* LCOV_EXCL_START */
 853                 ERR("info->sim_type is invalid(%d) stop sim init !!!", info->sim_type);
 854                 return CONTACTS_ERROR_SYSTEM;
 855                 /* LCOV_EXCL_STOP */
 856         }
 857
 858         RETVM_IF(TAPI_API_SUCCESS != ret, CONTACTS_ERROR_SYSTEM,
 859                         "tel_get_sim_(usim)_meta_info(type:%d) Fail(%d)", info->sim_type, ret);
 860
 861         return CONTACTS_ERROR_NONE;
 862 }
 863
 864 static void __ctsvc_server_sim_noti_pb_status(TapiHandle *handle, const char *noti_id, void *data, void *user_data)
 865 {
 866         CTS_FN_CALL;
 867         int ret = 0;
 868         ctsvc_sim_info_s *info = (ctsvc_sim_info_s*)user_data;
 869         TelSimPbStatus_t *pb_status = (TelSimPbStatus_t *)data;
 870         RET_IF(NULL == pb_status);
 871         INFO("received pb status noti : b_3g[%d], b_adn[%d], b_fdn[%d]", pb_status->pb_list.b_3g, pb_status->pb_list.b_adn, pb_status->pb_list.b_fdn);
 872
 873         if ((1 == pb_status->pb_list.b_3g) || (1 == pb_status->pb_list.b_adn)) {
 874                 if (info->initialized)
 875                         return;
 876                 ret = __ctsvc_server_sim_init_meta_info(info);
 877                 WARN_IF(CONTACTS_ERROR_NONE != ret, "__ctsvc_server_sim_init_meta_info() Fail(%d)", ret);
 878         } else if ((1 == pb_status->pb_list.b_fdn) && (0 == pb_status->pb_list.b_adn)
 879                         && (TAPI_SIM_PB_ADN == info->sim_type)) {
 880                 /* FDN on : can not import sim contacts */
 881                 INFO("This is sim card is 2G and FDN on status. sim phonebook will be block");
 882                 info->initialized = false;
 883                 __ctsvc_server_sim_init_import_info(info);
 884         } else {
 885                 /* LCOV_EXCL_START */
 886                 ERR("This noti did not control !!!");
 887                 /* LCOV_EXCL_STOP */
 888         }
 889 }
 890
 891 static void __ctsvc_server_sim_noti_sim_refreshed(TapiHandle *handle, const char *noti_id, void *data, void *user_data)
 892 {
 893         CTS_FN_CALL;
 894         ctsvc_sim_info_s *info = (ctsvc_sim_info_s*)user_data;
 895
 896         INFO("Recieved SIM Refresh event");
 897         info->initialized = false;
 898         __ctsvc_server_sim_init_import_info(info);
 899 }
 900
 901 static void __ctsvc_server_sim_get_info(ctsvc_sim_info_s *info)
 902 {
 903         int ret;
 904         int sim_stat = -1;
 905         TelSimPbList_t pb_list = {0,};
 906
 907         ret = __ctsvc_server_sim_get_type_and_iccid(info);
 908         WARN_IF(CONTACTS_ERROR_NONE != ret, "__ctsvc_server_sim_get_type_and_iccid() Fail(%d)", ret);
 909         ret = tel_get_sim_pb_init_info(info->handle, &sim_stat, &pb_list);
 910         if (TAPI_API_SUCCESS == ret && ((1 == pb_list.b_3g) || (1 == pb_list.b_adn))) {
 911                 ret = __ctsvc_server_sim_init_meta_info(info);
 912                 WARN_IF(CONTACTS_ERROR_NONE != ret, "__ctsvc_server_sim_init_meta_info() Fail(%d)", ret);
 913         }
 914
 915         ret = tel_register_noti_event(info->handle, TAPI_NOTI_PB_STATUS, __ctsvc_server_sim_noti_pb_status, info);
 916         WARN_IF(TAPI_API_SUCCESS != ret, "tel_register_noti_event() Fail(%d)", ret);
 917
 918         ret = tel_register_noti_event(info->handle, TAPI_NOTI_SIM_REFRESHED, __ctsvc_server_sim_noti_sim_refreshed, info);
 919         WARN_IF(TAPI_API_SUCCESS != ret, "tel_register_noti_event() Fail(%d)", ret);
 920 }
 921
 922 static void __ctsvc_server_sim_status_events_cb(TapiHandle *handle, const char *noti_id, void *data, void *user_data)
 923 {
 924         int ret;
 925
 926         RET_IF(NULL == data);
 927         RET_IF(NULL == user_data);
 928
 929         TelSimCardStatus_t status = *(int *)data;
 930         ctsvc_sim_info_s *info = (ctsvc_sim_info_s *)user_data;
 931
 932         if (TAPI_SIM_STATUS_SIM_INIT_COMPLETED != status) {
 933                 /* LCOV_EXCL_START */
 934                 ERR("sim is not ready (%d)", status);
 935                 return;
 936                 /* LCOV_EXCL_STOP */
 937         }
 938         INFO("sim is Ready");
 939
 940         ret = tel_deregister_noti_event(info->handle, TAPI_NOTI_SIM_STATUS);
 941         WARN_IF(TAPI_API_SUCCESS != ret, "tel_deregister_noti_event() Fail(%d)", ret);
 942
 943         ctsvc_server_stop_timeout();
 944         __ctsvc_server_sim_get_info(info);
 945         ctsvc_server_start_timeout();
 946 }
 947
 948 static int __ctsvc_server_sim_init_info()
 949 {
 950         int ret;
 951         char **cp_name = NULL;
 952         int i;
 953         unsigned int cp_index = 0;
 954
 955 #if !GLIB_CHECK_VERSION(2, 35, 0)
 956         g_type_init();
 957 #endif
 958         cp_name = tel_get_cp_name_list();
 959         RETVM_IF(NULL == cp_name, CONTACTS_ERROR_SYSTEM, "tel_get_cp_name_list() Fail");
 960
 961         ret = ctsvc_server_delete_sdn_contact(-1);
 962         WARN_IF(CONTACTS_ERROR_NONE != ret, "ctsvc_server_delete_sdn_contact() Fail(%d)", ret);
 963
 964         while (cp_name[cp_index])
 965                 cp_index++;
 966
 967         cp_index = 0;
 968         while (cp_name[cp_index]) {
 969                 TelSimCardStatus_t status = TAPI_SIM_STATUS_CARD_ERROR;
 970                 int card_changed = 0;
 971                 ctsvc_sim_info_s *info = calloc(1, sizeof(ctsvc_sim_info_s));
 972                 if (NULL == info) {
 973                         /* LCOV_EXCL_START */
 974                         ERR("calloc() Fail");
 975                         g_strfreev(cp_name);
 976                         return CONTACTS_ERROR_OUT_OF_MEMORY;
 977                         /* LCOV_EXCL_STOP */
 978                 }
 979                 info->cp_name = strdup(cp_name[cp_index]);
 980                 INFO("SIM cp_name[%d] : %s", cp_index, info->cp_name);
 981                 info->sim_slot_no = cp_index;
 982                 info->sim_info_id = -1;
 983                 info->sim_type = TAPI_SIM_PB_UNKNOWNN;
 984                 info->initialized = false;
 985                 info->sim_unique_id = NULL;
 986
 987                 /* initialize file_record meta info */
 988                 for (i = 0; i < TAPI_PB_MAX_FILE_CNT; i++) {
 989                         info->file_record[i].support = false;
 990                         info->file_record[i].index_max = 0;
 991                         info->file_record[i].text_max = 0;
 992                         info->file_record[i].used_count = 0;
 993                 }
 994
 995                 __ctsvc_server_sim_get_tapi_handle(info);
 996                 if (NULL == info->handle) {
 997                         /* LCOV_EXCL_START */
 998                         ERR("__ctsvc_server_sim_get_tapi_handle() Fail");
 999                         continue;
1000                         /* LCOV_EXCL_STOP */
1001                 }
1002                 __ctsvc_sim_info = g_slist_append(__ctsvc_sim_info, (void*)info);
1003                 cp_index++;
1004
1005                 ret = tel_get_sim_init_info(info->handle, &status, &card_changed);
1006                 if (TAPI_API_SUCCESS != ret || TAPI_SIM_STATUS_SIM_INIT_COMPLETED != status) {
1007                         /* LCOV_EXCL_START */
1008                         ERR("tel_get_sim_init_info() ret(%d), status(%d)", ret, status);
1009                         ret = tel_register_noti_event(info->handle, TAPI_NOTI_SIM_STATUS, __ctsvc_server_sim_status_events_cb, info);
1010                         /* LCOV_EXCL_STOP */
1011                         if (TAPI_API_SUCCESS != ret)
1012                                 /* LCOV_EXCL_START */
1013                                 ERR("tel_register_noti_event() Fail(%d)", ret);
1014                         /* LCOV_EXCL_STOP */
1015                 } else {
1016                         __ctsvc_server_sim_get_info(info);
1017                 }
1018         }
1019
1020         g_strfreev(cp_name);
1021
1022         return CONTACTS_ERROR_NONE;
1023 }
1024
1025 static void __ctsvc_server_telephony_ready_cb(keynode_t *key, void *data)
1026 {
1027         int bReady = 0;
1028         vconf_get_bool(VCONFKEY_TELEPHONY_READY, &bReady);
1029
1030         if (0 == bReady) {
1031                 /* LCOV_EXCL_START */
1032                 ERR("telephony is not ready ");
1033                 return;
1034                 /* LCOV_EXCL_STOP */
1035         }
1036         INFO("telephony is Ready");
1037
1038         vconf_ignore_key_changed(VCONFKEY_TELEPHONY_READY, __ctsvc_server_telephony_ready_cb);
1039         __ctsvc_tapi_cb = false;
1040
1041         ctsvc_server_stop_timeout();
1042         __ctsvc_server_sim_init_info();
1043         ctsvc_server_start_timeout();
1044 }
1045
1046
1047 int ctsvc_server_sim_init()
1048 {
1049         int bReady = 0;
1050         vconf_get_bool(VCONFKEY_TELEPHONY_READY, &bReady);
1051
1052         if (0 == bReady) {
1053                 /* LCOV_EXCL_START */
1054                 ERR("telephony is not ready ");
1055                 vconf_notify_key_changed(VCONFKEY_TELEPHONY_READY, __ctsvc_server_telephony_ready_cb, NULL);
1056                 __ctsvc_tapi_cb = true;
1057                 return CONTACTS_ERROR_NONE;
1058                 /* LCOV_EXCL_STOP */
1059         }
1060
1061         return __ctsvc_server_sim_init_info();
1062 }
1063
1064 int ctsvc_server_sim_final(void)
1065 {
1066         CTS_FN_CALL;
1067         GSList *info_cursor = NULL;
1068         int ret = 0;
1069
1070         if (__ctsvc_tapi_cb)
1071                 vconf_ignore_key_changed(VCONFKEY_TELEPHONY_READY, __ctsvc_server_telephony_ready_cb);
1072
1073         for (info_cursor = __ctsvc_sim_info; info_cursor; info_cursor = info_cursor->next) {
1074                 ctsvc_sim_info_s *info = info_cursor->data;
1075                 free(info->cp_name);
1076                 free(info->sim_unique_id);
1077
1078                 if (info->handle) {
1079                         ret = tel_deregister_noti_event(info->handle, TAPI_NOTI_SIM_STATUS);
1080                         WARN_IF(TAPI_API_SUCCESS != ret, "tel_deregister_noti_event() Fail(%d)", ret);
1081                         ret = tel_deinit(info->handle);
1082                         WARN_IF(TAPI_API_SUCCESS != ret, "tel_deinit() Fail(%d)", ret);
1083                 }
1084
1085                 __ctsvc_server_sim_init_import_info(info);
1086
1087                 free(info);
1088         }
1089
1090         return CONTACTS_ERROR_NONE;
1091 }
1092