src/telephony_network.c

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17
  18 #include <telephony_network.h>
  19 #include <vconf-keys.h>
  20 #include <vconf.h>
  21 #include <string.h>
  22 #include <stdlib.h>
  23 #include <stdio.h>
  24 #include <glib.h>
  25 #include <dlog.h>
  26
  27 #ifdef LOG_TAG
  28 #undef LOG_TAG
  29 #endif
  30 #define LOG_TAG "CAPI_TELEPHONY_NETWORK_INFO"
  31
  32 // whether vconf_notify_key_changed is registered or not
  33 static bool flight_mode_is_registered = false;
  34 static bool svctype_is_registered = false;
  35 static bool svc_cs_is_registered = false;
  36 static bool cell_id_is_registered = false;
  37 static bool rssi_is_registered = false;
  38 static bool roaming_is_registered = false;
  39
  40 typedef struct _telephony_cb_data
  41 {
  42         int previous_value;
  43         const void* cb;
  44         void* user_data;
  45 } telephony_cb_data;
  46
  47 // Callback function data
  48 static telephony_cb_data service_state_cb = {NETWORK_INFO_SERVICE_STATE_OUT_OF_SERVICE, NULL, NULL};
  49 static telephony_cb_data cell_id_cb = {0, NULL, NULL};
  50 static telephony_cb_data rssi_cb = {NETWORK_INFO_RSSI_0, NULL, NULL};
  51 static telephony_cb_data roaming_cb = {false, NULL, NULL};
  52
  53 // Callback function adapter
  54 static void __telephony_service_changed_cb_adapter(keynode_t *node, void* user_data);
  55 static void __cell_id_changed_cb_adapter(keynode_t *node, void* user_data);
  56 static void __rssi_changed_cb_adapter(keynode_t *node, void* user_data);
  57 static void __roaming_changed_cb_adapter(keynode_t *node, void* user_data);
  58 static char* __convert_error_code_to_string(network_info_error_e error_code);
  59 static int __check_service_state(char* function_name);
  60
  61 // Internal Macros
  62 #define NETWORK_INFO_CHECK_INPUT_PARAMETER(arg) \
  63         if( arg == NULL ) \
  64         { \
  65                 LOGE("[%s] INVALID_PARAMETER(0x%08x)", __FUNCTION__, NETWORK_INFO_ERROR_INVALID_PARAMETER); \
  66                 return NETWORK_INFO_ERROR_INVALID_PARAMETER; \
  67         }
  68
  69
  70 int network_info_get_lac(int* lac)
  71 {
  72         int ret = NETWORK_INFO_ERROR_NONE;
  73
  74         NETWORK_INFO_CHECK_INPUT_PARAMETER(lac);
  75
  76         ret = __check_service_state((char*)__FUNCTION__);
  77         if( ret != NETWORK_INFO_ERROR_NONE )
  78         {
  79                 return ret;
  80         }
  81
  82         if( vconf_get_int(VCONFKEY_TELEPHONY_LAC, lac) != 0 )
  83         {
  84                 LOGE("[%s] OPERATION_FAILED(0x%08x)", __FUNCTION__, NETWORK_INFO_ERROR_OPERATION_FAILED);
  85                 return NETWORK_INFO_ERROR_OPERATION_FAILED;
  86         }
  87
  88         return NETWORK_INFO_ERROR_NONE;
  89 }
  90
  91
  92 int network_info_get_cell_id(int* cell_id)
  93 {
  94         int ret = NETWORK_INFO_ERROR_NONE;
  95
  96         NETWORK_INFO_CHECK_INPUT_PARAMETER(cell_id);
  97
  98         ret = __check_service_state((char*)__FUNCTION__);
  99         if( ret != NETWORK_INFO_ERROR_NONE )
 100         {
 101                 return ret;
 102         }
 103
 104         if( vconf_get_int(VCONFKEY_TELEPHONY_CELLID, cell_id) != 0 )
 105         {
 106                 LOGE("[%s] OPERATION_FAILED(0x%08x)", __FUNCTION__, NETWORK_INFO_ERROR_OPERATION_FAILED);
 107                 return NETWORK_INFO_ERROR_OPERATION_FAILED;
 108         }
 109
 110         return NETWORK_INFO_ERROR_NONE;
 111 }
 112
 113
 114 int network_info_get_rssi(network_info_rssi_e* rssi)
 115 {
 116         int ret = NETWORK_INFO_ERROR_NONE;
 117
 118         NETWORK_INFO_CHECK_INPUT_PARAMETER(rssi);
 119
 120         ret = __check_service_state((char*)__FUNCTION__);
 121         if( ret != NETWORK_INFO_ERROR_NONE )
 122         {
 123                 return ret;
 124         }
 125
 126         if( vconf_get_int(VCONFKEY_TELEPHONY_RSSI, (int *)rssi) != 0 )
 127         {
 128                 LOGE("[%s] OPERATION_FAILED(0x%08x)", __FUNCTION__, NETWORK_INFO_ERROR_OPERATION_FAILED);
 129                 return NETWORK_INFO_ERROR_OPERATION_FAILED;
 130         }
 131
 132         return NETWORK_INFO_ERROR_NONE;
 133 }
 134
 135
 136 int network_info_is_roaming(bool* is_roaming)
 137 {
 138         int roaming_state = 0;
 139         int ret = NETWORK_INFO_ERROR_NONE;
 140
 141         NETWORK_INFO_CHECK_INPUT_PARAMETER(is_roaming);
 142
 143         ret = __check_service_state((char*)__FUNCTION__);
 144         if( ret != NETWORK_INFO_ERROR_NONE )
 145         {
 146                 return ret;
 147         }
 148
 149         if( vconf_get_int(VCONFKEY_TELEPHONY_SVC_ROAM, &roaming_state) != 0 )
 150         {
 151                 LOGE("[%s] OPERATION_FAILED(0x%08x)", __FUNCTION__, NETWORK_INFO_ERROR_OPERATION_FAILED);
 152                 return NETWORK_INFO_ERROR_OPERATION_FAILED;
 153         }
 154
 155         if( roaming_state == VCONFKEY_TELEPHONY_SVC_ROAM_ON )
 156         {
 157                 *is_roaming = true;
 158         }
 159         else
 160         {
 161                 *is_roaming = false;
 162         }
 163
 164         return NETWORK_INFO_ERROR_NONE;
 165 }
 166
 167
 168 int network_info_get_mcc(char** mcc)
 169 {
 170         char plmn_str[32] = "";
 171         int plmn_int = 0;
 172         int mcc_length = 3;
 173         int ret = NETWORK_INFO_ERROR_NONE;
 174
 175         NETWORK_INFO_CHECK_INPUT_PARAMETER(mcc);
 176
 177         ret = __check_service_state((char*)__FUNCTION__);
 178         if( ret != NETWORK_INFO_ERROR_NONE )
 179         {
 180                 return ret;
 181         }
 182
 183         if( vconf_get_int(VCONFKEY_TELEPHONY_PLMN, &plmn_int) != 0 )
 184         {
 185                 LOGE("[%s] OPERATION_FAILED(0x%08x)", __FUNCTION__, NETWORK_INFO_ERROR_OPERATION_FAILED);
 186                 return NETWORK_INFO_ERROR_OPERATION_FAILED;
 187         }
 188
 189         snprintf(plmn_str, 32, "%d", plmn_int);
 190         *mcc = (char*)malloc(sizeof(char) * (mcc_length+1));
 191         if( *mcc == NULL )
 192         {
 193                 LOGE("[%s] OUT_OF_MEMORY(0x%08x)", __FUNCTION__, NETWORK_INFO_ERROR_OUT_OF_MEMORY);
 194                 return NETWORK_INFO_ERROR_OUT_OF_MEMORY;
 195         }
 196         memset(*mcc, 0x00, mcc_length+1);
 197         strncpy(*mcc, plmn_str, mcc_length);
 198
 199         return NETWORK_INFO_ERROR_NONE;
 200 }
 201
 202
 203 int network_info_get_mnc(char** mnc)
 204 {
 205         char plmn_str[32] = "";
 206         int plmn_int = 0;
 207         int mnc_length = 3; //mcc_length can 2 or 3 depending on a network, so have to proper way to get the exact length of mcc
 208         int ret = NETWORK_INFO_ERROR_NONE;
 209
 210         NETWORK_INFO_CHECK_INPUT_PARAMETER(mnc);
 211
 212         ret = __check_service_state((char*)__FUNCTION__);
 213         if( ret != NETWORK_INFO_ERROR_NONE )
 214         {
 215                 return ret;
 216         }
 217
 218         if( vconf_get_int(VCONFKEY_TELEPHONY_PLMN, &plmn_int) != 0 )
 219         {
 220                 LOGE("[%s] OPERATION_FAILED(0x%08x)", __FUNCTION__, NETWORK_INFO_ERROR_OPERATION_FAILED);
 221                 return NETWORK_INFO_ERROR_OPERATION_FAILED;
 222         }
 223
 224         snprintf(plmn_str, 32, "%d", plmn_int);
 225         *mnc = (char*)malloc(sizeof(char) * (mnc_length+1));
 226         if( *mnc == NULL )
 227         {
 228                 LOGE("[%s] OUT_OF_MEMORY(0x%08x)", __FUNCTION__, NETWORK_INFO_ERROR_OUT_OF_MEMORY);
 229                 return NETWORK_INFO_ERROR_OUT_OF_MEMORY;
 230         }
 231         memset(*mnc, 0x00, mnc_length+1);
 232         strncpy(*mnc, plmn_str+3, mnc_length);
 233
 234         return NETWORK_INFO_ERROR_NONE;
 235 }
 236
 237
 238 int network_info_get_provider_name(char** provider_name)
 239 {
 240         char* provider_name_p = NULL;
 241         int ret = NETWORK_INFO_ERROR_NONE;
 242
 243         NETWORK_INFO_CHECK_INPUT_PARAMETER(provider_name);
 244
 245         ret = __check_service_state((char*)__FUNCTION__);
 246         if( ret != NETWORK_INFO_ERROR_NONE )
 247         {
 248                 return ret;
 249         }
 250
 251         provider_name_p = vconf_get_str(VCONFKEY_TELEPHONY_NWNAME);
 252         if( provider_name_p == NULL )
 253         {
 254                 LOGE("[%s] OPERATION_FAILED(0x%08x)", __FUNCTION__, NETWORK_INFO_ERROR_OPERATION_FAILED);
 255                 return NETWORK_INFO_ERROR_OPERATION_FAILED;
 256         }
 257
 258         *provider_name = provider_name_p;
 259
 260         return NETWORK_INFO_ERROR_NONE;
 261 }
 262
 263
 264 int network_info_get_type(network_info_type_e* network_type)
 265 {
 266         int service_type = 0;
 267         int ret = NETWORK_INFO_ERROR_NONE;
 268
 269         NETWORK_INFO_CHECK_INPUT_PARAMETER(network_type);
 270
 271         ret = __check_service_state((char*)__FUNCTION__);
 272         if( ret != NETWORK_INFO_ERROR_NONE )
 273         {
 274                 return ret;
 275         }
 276
 277         if( vconf_get_int(VCONFKEY_TELEPHONY_SVCTYPE, &service_type) != 0 )
 278         {
 279                 LOGE("[%s] OPERATION_FAILED(0x%08x)", __FUNCTION__, NETWORK_INFO_ERROR_OPERATION_FAILED);
 280                 return NETWORK_INFO_ERROR_OPERATION_FAILED;
 281         }
 282
 283         switch(service_type)
 284         {
 285                 case VCONFKEY_TELEPHONY_SVCTYPE_2G:
 286                         *network_type = NETWORK_INFO_TYPE_GSM;
 287                         break;
 288                 case VCONFKEY_TELEPHONY_SVCTYPE_2_5G:
 289                         *network_type = NETWORK_INFO_TYPE_GPRS;
 290                         break;
 291                 case VCONFKEY_TELEPHONY_SVCTYPE_2_5G_EDGE:
 292                         *network_type = NETWORK_INFO_TYPE_EDGE;
 293                         break;
 294                 case VCONFKEY_TELEPHONY_SVCTYPE_3G:
 295                         *network_type = NETWORK_INFO_TYPE_UMTS;;
 296                         break;
 297                 case VCONFKEY_TELEPHONY_SVCTYPE_HSDPA:
 298                         *network_type = NETWORK_INFO_TYPE_HSDPA;
 299                         break;
 300                 default:
 301                         *network_type = NETWORK_INFO_TYPE_UNKNOWN;
 302                         break;
 303         }
 304
 305         return NETWORK_INFO_ERROR_NONE;
 306 }
 307
 308
 309 int network_info_get_service_state(network_info_service_state_e* network_service_state)
 310 {
 311         int service_type = 0;
 312         int cs_status = 0;
 313         int is_flight_mode = 0;
 314
 315         NETWORK_INFO_CHECK_INPUT_PARAMETER(network_service_state);
 316
 317         // get service type
 318         if( vconf_get_int(VCONFKEY_TELEPHONY_SVCTYPE, &service_type) != 0 )
 319         {
 320                 LOGE("[%s] OPERATION_FAILED(0x%08x) : fail to get service type", __FUNCTION__, NETWORK_INFO_ERROR_OPERATION_FAILED);
 321                 return NETWORK_INFO_ERROR_OPERATION_FAILED;
 322         }
 323
 324         if( service_type == VCONFKEY_TELEPHONY_SVCTYPE_EMERGENCY )
 325         {
 326                 *network_service_state = NETWORK_INFO_SERVICE_STATE_EMERGENCY_ONLY;
 327                 return NETWORK_INFO_ERROR_NONE;
 328         }
 329
 330         // get circuit service
 331         if( vconf_get_int(VCONFKEY_TELEPHONY_SVC_CS, &cs_status) != 0 )
 332         {
 333                 LOGE("[%s] OPERATION_FAILED(0x%08x) : fail to get the status of cs", __FUNCTION__, NETWORK_INFO_ERROR_OPERATION_FAILED);
 334                 return NETWORK_INFO_ERROR_OPERATION_FAILED;
 335         }
 336
 337         if( cs_status == VCONFKEY_TELEPHONY_SVC_CS_ON )
 338         {
 339                 *network_service_state = NETWORK_INFO_SERVICE_STATE_IN_SERVICE;
 340                 return NETWORK_INFO_ERROR_NONE;
 341         }
 342
 343         // get flight mode
 344         if( vconf_get_bool(VCONFKEY_TELEPHONY_FLIGHT_MODE, &is_flight_mode) != 0 )
 345         {
 346                 LOGE("[%s] OPERATION_FAILED(0x%08x) : fail to get flight mode", __FUNCTION__, NETWORK_INFO_ERROR_OPERATION_FAILED);
 347                 return NETWORK_INFO_ERROR_OPERATION_FAILED;
 348         }
 349
 350         if( is_flight_mode == 1 )
 351         {
 352                 *network_service_state = NETWORK_INFO_SERVICE_STATE_RADIO_OFF;
 353                 return NETWORK_INFO_ERROR_NONE;
 354         }
 355
 356         *network_service_state = NETWORK_INFO_SERVICE_STATE_OUT_OF_SERVICE;
 357         return NETWORK_INFO_ERROR_NONE;
 358 }
 359
 360 int network_info_set_service_state_changed_cb(network_info_service_state_changed_cb callback, void* user_data)
 361 {
 362         int ret = NETWORK_INFO_ERROR_OPERATION_FAILED;
 363         network_info_service_state_e service_state = NETWORK_INFO_SERVICE_STATE_OUT_OF_SERVICE;
 364
 365         NETWORK_INFO_CHECK_INPUT_PARAMETER(callback);
 366
 367         ret = network_info_get_service_state(&service_state);
 368         if( ret != NETWORK_INFO_ERROR_NONE )
 369         {
 370                 LOGE("[%s] %s(0x%08x) : fail to get current service state", __FUNCTION__, __convert_error_code_to_string(ret), ret);
 371                 return ret;
 372         }
 373
 374         if( flight_mode_is_registered == false)
 375         {
 376                 if( vconf_notify_key_changed(VCONFKEY_TELEPHONY_FLIGHT_MODE, (vconf_callback_fn)__telephony_service_changed_cb_adapter, NULL) != 0 )
 377                 {
 378                         LOGE("[%s] OPERATION_FAILED(0x%08x) : fail to register callback of flight mode", __FUNCTION__, NETWORK_INFO_ERROR_OPERATION_FAILED);
 379                         return NETWORK_INFO_ERROR_OPERATION_FAILED;
 380                 }
 381                 flight_mode_is_registered = true;
 382         }
 383
 384         if( svctype_is_registered == false )
 385         {
 386                 if(vconf_notify_key_changed(VCONFKEY_TELEPHONY_SVCTYPE, (vconf_callback_fn)__telephony_service_changed_cb_adapter, NULL) != 0)
 387                 {
 388                         LOGE("[%s] OPERATION_FAILED(0x%08x) : fail to register callback of service type", __FUNCTION__, NETWORK_INFO_ERROR_OPERATION_FAILED);
 389                         return NETWORK_INFO_ERROR_OPERATION_FAILED;
 390                 }
 391                 svctype_is_registered = true;
 392         }
 393
 394         if( svc_cs_is_registered == false )
 395         {
 396                 if(vconf_notify_key_changed(VCONFKEY_TELEPHONY_SVC_CS, (vconf_callback_fn)__telephony_service_changed_cb_adapter, NULL) != 0)
 397                 {
 398                         LOGE("[%s] OPERATION_FAILED(0x%08x) : fail to register callback of circuit service", __FUNCTION__, NETWORK_INFO_ERROR_OPERATION_FAILED);
 399                         return NETWORK_INFO_ERROR_OPERATION_FAILED;
 400                 }
 401                 svc_cs_is_registered = true;
 402         }
 403
 404         service_state_cb.previous_value = service_state;
 405         service_state_cb.cb = callback;
 406         service_state_cb.user_data = user_data;
 407
 408         return NETWORK_INFO_ERROR_NONE;
 409 }
 410
 411 int network_info_unset_service_state_changed_cb()
 412 {
 413         if( flight_mode_is_registered == true )
 414         {
 415                 if( vconf_ignore_key_changed(VCONFKEY_TELEPHONY_FLIGHT_MODE, (vconf_callback_fn)__telephony_service_changed_cb_adapter) != 0 )
 416                 {
 417                         LOGE("[%s] OPERATION_FAILED(0x%08x) : fail to unregister callback of flight mode", __FUNCTION__, NETWORK_INFO_ERROR_OPERATION_FAILED);
 418                         return NETWORK_INFO_ERROR_OPERATION_FAILED;
 419                 }
 420                 flight_mode_is_registered = false;
 421         }
 422
 423         if( svctype_is_registered == true )
 424         {
 425                 if(vconf_ignore_key_changed(VCONFKEY_TELEPHONY_SVCTYPE, (vconf_callback_fn)__telephony_service_changed_cb_adapter) != 0)
 426                 {
 427                         LOGE("[%s] OPERATION_FAILED(0x%08x) : fail to unregister callback of service type", __FUNCTION__, NETWORK_INFO_ERROR_OPERATION_FAILED);
 428                         return NETWORK_INFO_ERROR_OPERATION_FAILED;
 429                 }
 430                 svctype_is_registered = false;
 431         }
 432
 433         if( svc_cs_is_registered == true )
 434         {
 435                 if(vconf_ignore_key_changed(VCONFKEY_TELEPHONY_SVC_CS, (vconf_callback_fn)__telephony_service_changed_cb_adapter) != 0)
 436                 {
 437                         LOGE("[%s] OPERATION_FAILED(0x%08x) : fail to unregister callback of circuit service", __FUNCTION__, NETWORK_INFO_ERROR_OPERATION_FAILED);
 438                         return NETWORK_INFO_ERROR_OPERATION_FAILED;
 439                 }
 440                 svc_cs_is_registered = false;
 441         }
 442
 443         service_state_cb.previous_value = NETWORK_INFO_SERVICE_STATE_OUT_OF_SERVICE;
 444         service_state_cb.cb = NULL;
 445         service_state_cb.user_data = NULL;
 446
 447         return NETWORK_INFO_ERROR_NONE;
 448 }
 449
 450 int network_info_set_cell_id_changed_cb(network_info_cell_id_changed_cb callback, void* user_data)
 451 {
 452         int cell_id = -1;
 453         int ret = NETWORK_INFO_ERROR_NONE;
 454
 455         NETWORK_INFO_CHECK_INPUT_PARAMETER(callback);
 456
 457         if (cell_id_is_registered == false) {   /* Not yet registered */
 458                 if (vconf_notify_key_changed(VCONFKEY_TELEPHONY_CELLID,
 459                                 (vconf_callback_fn)__cell_id_changed_cb_adapter, NULL) != 0) {
 460                         LOGE("[%s] OPERATION_FAILED(0x%08x) : fail to register callback function", __FUNCTION__, NETWORK_INFO_ERROR_OPERATION_FAILED);
 461                         return NETWORK_INFO_ERROR_OPERATION_FAILED;
 462                 }
 463                 cell_id_is_registered = true;
 464         }
 465
 466         /* Callback details */
 467         ret = network_info_get_cell_id(&cell_id);
 468         if (ret == NETWORK_INFO_ERROR_OPERATION_FAILED) {
 469                 cell_id_cb.previous_value = -1;
 470         } else {
 471                 cell_id_cb.previous_value = cell_id;
 472         }
 473         cell_id_cb.cb = callback;
 474         cell_id_cb.user_data = user_data;
 475
 476         return NETWORK_INFO_ERROR_NONE;
 477 }
 478
 479 int network_info_unset_cell_id_changed_cb()
 480 {
 481         if( cell_id_is_registered == true )
 482         {
 483                 if( vconf_ignore_key_changed(VCONFKEY_TELEPHONY_CELLID, (vconf_callback_fn)__cell_id_changed_cb_adapter) != 0 )
 484                 {
 485                         LOGE("[%s] OPERATION_FAILED(0x%08x) : fail to unregister callback function", __FUNCTION__, NETWORK_INFO_ERROR_OPERATION_FAILED);
 486                         return NETWORK_INFO_ERROR_OPERATION_FAILED;
 487                 }
 488
 489                 cell_id_is_registered = false;
 490                 cell_id_cb.previous_value = 0;
 491                 cell_id_cb.cb = NULL;
 492                 cell_id_cb.user_data = NULL;
 493         }
 494
 495         return NETWORK_INFO_ERROR_NONE;
 496 }
 497
 498 int network_info_set_rssi_changed_cb(network_info_rssi_changed_cb callback, void* user_data)
 499 {
 500         network_info_rssi_e rssi = NETWORK_INFO_RSSI_0;
 501         int ret = NETWORK_INFO_ERROR_NONE;
 502
 503         NETWORK_INFO_CHECK_INPUT_PARAMETER(callback);
 504
 505         if (rssi_is_registered == false) {      /* Not yet registered */
 506                 if (vconf_notify_key_changed(VCONFKEY_TELEPHONY_RSSI,
 507                                 (vconf_callback_fn)__rssi_changed_cb_adapter,
 508                                 NULL) != 0) {
 509                         LOGE("[%s] OPERATION_FAILED(0x%08x) : fail to register callback function", __FUNCTION__, NETWORK_INFO_ERROR_OPERATION_FAILED);
 510                 return NETWORK_INFO_ERROR_OPERATION_FAILED;
 511                 }
 512                 rssi_is_registered = true;
 513         }
 514
 515         /* Callback details */
 516         ret = network_info_get_rssi(&rssi);
 517         if (ret == NETWORK_INFO_ERROR_OPERATION_FAILED) {
 518                 rssi_cb.previous_value = NETWORK_INFO_RSSI_0;
 519         } else {
 520                 rssi_cb.previous_value = rssi;
 521         }
 522         rssi_cb.cb = callback;
 523         rssi_cb.user_data = user_data;
 524
 525         return NETWORK_INFO_ERROR_NONE;
 526 }
 527
 528 int network_info_unset_rssi_changed_cb()
 529 {
 530         if( rssi_is_registered == true )
 531         {
 532                 if( vconf_ignore_key_changed(VCONFKEY_TELEPHONY_RSSI, (vconf_callback_fn)__rssi_changed_cb_adapter) != 0 )
 533                 {
 534                         LOGE("[%s] OPERATION_FAILED(0x%08x) : fail to unregister callback function", __FUNCTION__, NETWORK_INFO_ERROR_OPERATION_FAILED);
 535                         return NETWORK_INFO_ERROR_OPERATION_FAILED;
 536                 }
 537
 538                 rssi_is_registered = false;
 539                 rssi_cb.previous_value = NETWORK_INFO_RSSI_0;
 540                 rssi_cb.cb = NULL;
 541                 rssi_cb.user_data = NULL;
 542         }
 543
 544         return NETWORK_INFO_ERROR_NONE;
 545 }
 546
 547 int network_info_set_roaming_state_changed_cb(network_info_roaming_state_changed_cb callback, void *user_data)
 548 {
 549         bool is_roaming = false;
 550         int ret = NETWORK_INFO_ERROR_NONE;
 551
 552         NETWORK_INFO_CHECK_INPUT_PARAMETER(callback);
 553
 554         if (roaming_is_registered == false) {   /* Not yet registered */
 555                 if(vconf_notify_key_changed(VCONFKEY_TELEPHONY_SVC_ROAM,
 556                                 (vconf_callback_fn)__roaming_changed_cb_adapter, NULL) != 0) {
 557                         LOGE("[%s] OPERATION_FAILED(0x%08x) : fail to register callback function", __FUNCTION__, NETWORK_INFO_ERROR_OPERATION_FAILED);
 558                         return NETWORK_INFO_ERROR_OPERATION_FAILED;
 559                 }
 560                 roaming_is_registered = true;
 561         }
 562
 563         /* Callback details */
 564         ret = network_info_is_roaming(&is_roaming);
 565         if (ret == NETWORK_INFO_ERROR_OPERATION_FAILED) {
 566                 roaming_cb.previous_value = -1;
 567         } else {
 568                 roaming_cb.previous_value = is_roaming;
 569         }
 570         roaming_cb.cb = callback;
 571         roaming_cb.user_data = user_data;
 572
 573         return NETWORK_INFO_ERROR_NONE;
 574 }
 575
 576 int network_info_unset_roaming_state_changed_cb()
 577 {
 578         if( roaming_is_registered == true )
 579         {
 580                 if( vconf_ignore_key_changed(VCONFKEY_TELEPHONY_SVC_ROAM, (vconf_callback_fn)__roaming_changed_cb_adapter) != 0 )
 581                 {
 582                         LOGE("[%s] OPERATION_FAILED(0x%08x) : fail to unregister callback function", __FUNCTION__, NETWORK_INFO_ERROR_OPERATION_FAILED);
 583                         return NETWORK_INFO_ERROR_OPERATION_FAILED;
 584                 }
 585
 586                 roaming_is_registered = false;
 587                 roaming_cb.previous_value = false;
 588                 roaming_cb.cb = NULL;
 589                 roaming_cb.user_data = NULL;
 590         }
 591
 592         return NETWORK_INFO_ERROR_NONE;
 593 }
 594
 595 static void __telephony_service_changed_cb_adapter(keynode_t *node, void* user_data)
 596 {
 597         network_info_service_state_e status = NETWORK_INFO_SERVICE_STATE_OUT_OF_SERVICE;
 598
 599         if( service_state_cb.cb == NULL )
 600         {
 601                 return;
 602         }
 603
 604         if( network_info_get_service_state(&status) == NETWORK_INFO_ERROR_NONE )
 605         {
 606                 if( status != service_state_cb.previous_value )
 607                 {
 608                         ((network_info_service_state_changed_cb)(service_state_cb.cb))(status, service_state_cb.user_data);
 609                         service_state_cb.previous_value = status;
 610                 }
 611         }
 612 }
 613
 614 static void __cell_id_changed_cb_adapter(keynode_t *node, void* user_data)
 615 {
 616         int cell_id = 0;
 617
 618         if( cell_id_cb.cb == NULL )
 619         {
 620                 LOGI("[%s] There is no registered callback", __FUNCTION__);
 621                 return;
 622         }
 623
 624         if( network_info_get_cell_id(&cell_id) == NETWORK_INFO_ERROR_NONE )
 625         {
 626                 if( cell_id != cell_id_cb.previous_value )
 627                 {
 628                         LOGI("[%s] network_info_cell_id_changed_cb will be called", __FUNCTION__);
 629                         ((network_info_cell_id_changed_cb)(cell_id_cb.cb))(cell_id, cell_id_cb.user_data);
 630                         cell_id_cb.previous_value = cell_id;
 631                 }
 632         }
 633 }
 634
 635 static void __rssi_changed_cb_adapter(keynode_t *node, void* user_data)
 636 {
 637         network_info_rssi_e rssi = 0;
 638
 639         if( rssi_cb.cb == NULL )
 640         {
 641                 return;
 642         }
 643
 644         if( network_info_get_rssi(&rssi) == NETWORK_INFO_ERROR_NONE )
 645         {
 646                 if( rssi != rssi_cb.previous_value )
 647                 {
 648                         ((network_info_rssi_changed_cb)(rssi_cb.cb))(rssi, rssi_cb.user_data);
 649                         rssi_cb.previous_value = rssi;
 650                 }
 651         }
 652 }
 653
 654 static void __roaming_changed_cb_adapter(keynode_t *node, void* user_data)
 655 {
 656         bool is_roaming = 0;
 657
 658         if( roaming_cb.cb == NULL )
 659         {
 660                 return;
 661         }
 662
 663         if( network_info_is_roaming(&is_roaming) == NETWORK_INFO_ERROR_NONE )
 664         {
 665                 if( is_roaming != roaming_cb.previous_value )
 666                 {
 667                         ((network_info_roaming_state_changed_cb)(roaming_cb.cb))(is_roaming, roaming_cb.user_data);
 668                         roaming_cb.previous_value = is_roaming;
 669                 }
 670         }
 671 }
 672
 673
 674 static char* __convert_error_code_to_string(network_info_error_e error_code)
 675 {
 676         switch(error_code)
 677         {
 678                 case NETWORK_INFO_ERROR_OUT_OF_MEMORY:
 679                         return "OUT_OF_MEMORY";
 680                 case NETWORK_INFO_ERROR_INVALID_PARAMETER:
 681                         return "INVALID_PARAMETER";
 682                 case NETWORK_INFO_ERROR_OPERATION_FAILED:
 683                         return "OPERATION_FAILED";
 684                 case NETWORK_INFO_ERROR_OUT_OF_SERVICE:
 685                         return "OUT_OF_SERVICE";
 686                 default:
 687                         return "UNKNOWN";
 688         }
 689 }
 690
 691 static int __check_service_state(char* function_name)
 692 {
 693         network_info_service_state_e service_state = NETWORK_INFO_SERVICE_STATE_OUT_OF_SERVICE;
 694
 695         if( network_info_get_service_state(&service_state) != NETWORK_INFO_ERROR_NONE )
 696         {
 697                 LOGE("[%s] OPERATION_FAILED(0x%08x)", function_name, NETWORK_INFO_ERROR_OPERATION_FAILED);
 698                 return NETWORK_INFO_ERROR_OPERATION_FAILED;
 699         }
 700
 701         if( service_state != NETWORK_INFO_SERVICE_STATE_IN_SERVICE )
 702         {
 703                 LOGE("[%s] OUT_OF_SERVICE(0x%08x)", function_name, NETWORK_INFO_ERROR_OUT_OF_SERVICE);
 704                 return NETWORK_INFO_ERROR_OUT_OF_SERVICE;
 705         }
 706
 707         return NETWORK_INFO_ERROR_NONE;
 708 }
 709
 710
 711