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
 451 int network_info_set_cell_id_changed_cb(network_info_cell_id_changed_cb callback, void* user_data)
 452 {
 453         int cell_id = 0;
 454         int ret = NETWORK_INFO_ERROR_NONE;
 455
 456         NETWORK_INFO_CHECK_INPUT_PARAMETER(callback);
 457
 458         ret = network_info_get_cell_id(&cell_id);
 459         if( ret != NETWORK_INFO_ERROR_NONE )
 460         {
 461                 LOGE("[%s] %s(0x%08x) : fail to get current CELL ID", __FUNCTION__, __convert_error_code_to_string(ret), ret);
 462                 return ret;
 463         }
 464
 465         if( cell_id_is_registered == false)
 466         {
 467                 if( vconf_notify_key_changed(VCONFKEY_TELEPHONY_CELLID, (vconf_callback_fn)__cell_id_changed_cb_adapter, NULL) != 0 )
 468                 {
 469                         LOGE("[%s] OPERATION_FAILED(0x%08x) : fail to register callback function", __FUNCTION__, NETWORK_INFO_ERROR_OPERATION_FAILED);
 470                         return NETWORK_INFO_ERROR_OPERATION_FAILED;
 471                 }
 472
 473                 cell_id_is_registered = true;
 474         }
 475
 476         cell_id_cb.previous_value = cell_id;
 477         cell_id_cb.cb = callback;
 478         cell_id_cb.user_data = user_data;
 479
 480         return NETWORK_INFO_ERROR_NONE;
 481 }
 482
 483 int network_info_unset_cell_id_changed_cb()
 484 {
 485         if( cell_id_is_registered == true )
 486         {
 487                 if( vconf_ignore_key_changed(VCONFKEY_TELEPHONY_CELLID, (vconf_callback_fn)__cell_id_changed_cb_adapter) != 0 )
 488                 {
 489                         LOGE("[%s] OPERATION_FAILED(0x%08x) : fail to unregister callback function", __FUNCTION__, NETWORK_INFO_ERROR_OPERATION_FAILED);
 490                         return NETWORK_INFO_ERROR_OPERATION_FAILED;
 491                 }
 492
 493                 cell_id_is_registered = false;
 494                 cell_id_cb.previous_value = 0;
 495                 cell_id_cb.cb = NULL;
 496                 cell_id_cb.user_data = NULL;
 497         }
 498
 499         return NETWORK_INFO_ERROR_NONE;
 500 }
 501
 502 int network_info_set_rssi_changed_cb(network_info_rssi_changed_cb callback, void* user_data)
 503 {
 504         network_info_rssi_e rssi = NETWORK_INFO_RSSI_0;
 505         int ret = NETWORK_INFO_ERROR_NONE;
 506
 507         NETWORK_INFO_CHECK_INPUT_PARAMETER(callback);
 508
 509         ret = network_info_get_rssi(&rssi);
 510         if( ret != NETWORK_INFO_ERROR_NONE )
 511         {
 512                 LOGE("[%s] %s(0x%08x) : fail to get current RSSI", __FUNCTION__, __convert_error_code_to_string(ret), ret);
 513                 return ret;
 514         }
 515
 516         if( rssi_is_registered == false)
 517         {
 518                 if( vconf_notify_key_changed(VCONFKEY_TELEPHONY_RSSI, (vconf_callback_fn)__rssi_changed_cb_adapter, NULL) != 0 )
 519                 {
 520                         LOGE("[%s] OPERATION_FAILED(0x%08x) : fail to register callback function", __FUNCTION__, NETWORK_INFO_ERROR_OPERATION_FAILED);
 521                         return NETWORK_INFO_ERROR_OPERATION_FAILED;
 522                 }
 523
 524                 rssi_is_registered = true;
 525         }
 526
 527         rssi_cb.previous_value = rssi;
 528         rssi_cb.cb = callback;
 529         rssi_cb.user_data = user_data;
 530
 531         return NETWORK_INFO_ERROR_NONE;
 532 }
 533
 534 int network_info_unset_rssi_changed_cb()
 535 {
 536         if( rssi_is_registered == true )
 537         {
 538                 if( vconf_ignore_key_changed(VCONFKEY_TELEPHONY_RSSI, (vconf_callback_fn)__rssi_changed_cb_adapter) != 0 )
 539                 {
 540                         LOGE("[%s] OPERATION_FAILED(0x%08x) : fail to unregister callback function", __FUNCTION__, NETWORK_INFO_ERROR_OPERATION_FAILED);
 541                         return NETWORK_INFO_ERROR_OPERATION_FAILED;
 542                 }
 543
 544                 rssi_is_registered = false;
 545                 rssi_cb.previous_value = NETWORK_INFO_RSSI_0;
 546                 rssi_cb.cb = NULL;
 547                 rssi_cb.user_data = NULL;
 548         }
 549
 550         return NETWORK_INFO_ERROR_NONE;
 551 }
 552
 553 int network_info_set_roaming_state_changed_cb(network_info_roaming_state_changed_cb callback, void* user_data)
 554 {
 555         bool is_roaming = false;
 556         int ret = NETWORK_INFO_ERROR_NONE;
 557
 558         NETWORK_INFO_CHECK_INPUT_PARAMETER(callback);
 559
 560         ret = network_info_is_roaming(&is_roaming);
 561         if( ret != NETWORK_INFO_ERROR_NONE )
 562         {
 563                 LOGE("[%s] %s(0x%08x) : fail to get current roaming state", __FUNCTION__, __convert_error_code_to_string(ret), ret);
 564                 return ret;
 565         }
 566
 567         if( roaming_is_registered == false)
 568         {
 569                 if( vconf_notify_key_changed(VCONFKEY_TELEPHONY_SVC_ROAM, (vconf_callback_fn)__roaming_changed_cb_adapter, NULL) != 0 )
 570                 {
 571                         LOGE("[%s] OPERATION_FAILED(0x%08x) : fail to register callback function", __FUNCTION__, NETWORK_INFO_ERROR_OPERATION_FAILED);
 572                         return NETWORK_INFO_ERROR_OPERATION_FAILED;
 573                 }
 574
 575                 roaming_is_registered = true;
 576         }
 577
 578         roaming_cb.previous_value = is_roaming;
 579         roaming_cb.cb = callback;
 580         roaming_cb.user_data = user_data;
 581
 582         return NETWORK_INFO_ERROR_NONE;
 583 }
 584
 585 int network_info_unset_roaming_state_changed_cb()
 586 {
 587         if( roaming_is_registered == true )
 588         {
 589                 if( vconf_ignore_key_changed(VCONFKEY_TELEPHONY_SVC_ROAM, (vconf_callback_fn)__roaming_changed_cb_adapter) != 0 )
 590                 {
 591                         LOGE("[%s] OPERATION_FAILED(0x%08x) : fail to unregister callback function", __FUNCTION__, NETWORK_INFO_ERROR_OPERATION_FAILED);
 592                         return NETWORK_INFO_ERROR_OPERATION_FAILED;
 593                 }
 594
 595                 roaming_is_registered = false;
 596                 roaming_cb.previous_value = false;
 597                 roaming_cb.cb = NULL;
 598                 roaming_cb.user_data = NULL;
 599         }
 600
 601         return NETWORK_INFO_ERROR_NONE;
 602 }
 603
 604 static void __telephony_service_changed_cb_adapter(keynode_t *node, void* user_data)
 605 {
 606         network_info_service_state_e status = NETWORK_INFO_SERVICE_STATE_OUT_OF_SERVICE;
 607
 608         if( service_state_cb.cb == NULL )
 609         {
 610                 return;
 611         }
 612
 613         if( network_info_get_service_state(&status) == NETWORK_INFO_ERROR_NONE )
 614         {
 615                 if( status != service_state_cb.previous_value )
 616                 {
 617                         ((network_info_service_state_changed_cb)(service_state_cb.cb))(status, service_state_cb.user_data);
 618                         service_state_cb.previous_value = status;
 619                 }
 620         }
 621 }
 622
 623 static void __cell_id_changed_cb_adapter(keynode_t *node, void* user_data)
 624 {
 625         int cell_id = 0;
 626
 627         if( cell_id_cb.cb == NULL )
 628         {
 629                 LOGI("[%s] There is no registered callback", __FUNCTION__);
 630                 return;
 631         }
 632
 633         if( network_info_get_cell_id(&cell_id) == NETWORK_INFO_ERROR_NONE )
 634         {
 635                 if( cell_id != cell_id_cb.previous_value )
 636                 {
 637                         LOGI("[%s] network_info_cell_id_changed_cb will be called", __FUNCTION__);
 638                         ((network_info_cell_id_changed_cb)(cell_id_cb.cb))(cell_id, cell_id_cb.user_data);
 639                         cell_id_cb.previous_value = cell_id;
 640                 }
 641         }
 642 }
 643
 644 static void __rssi_changed_cb_adapter(keynode_t *node, void* user_data)
 645 {
 646         network_info_rssi_e rssi = 0;
 647
 648         if( rssi_cb.cb == NULL )
 649         {
 650                 return;
 651         }
 652
 653         if( network_info_get_rssi(&rssi) == NETWORK_INFO_ERROR_NONE )
 654         {
 655                 if( rssi != rssi_cb.previous_value )
 656                 {
 657                         ((network_info_rssi_changed_cb)(rssi_cb.cb))(rssi, rssi_cb.user_data);
 658                         rssi_cb.previous_value = rssi;
 659                 }
 660         }
 661 }
 662
 663 static void __roaming_changed_cb_adapter(keynode_t *node, void* user_data)
 664 {
 665         bool is_roaming = 0;
 666
 667         if( roaming_cb.cb == NULL )
 668         {
 669                 return;
 670         }
 671
 672         if( network_info_is_roaming(&is_roaming) == NETWORK_INFO_ERROR_NONE )
 673         {
 674                 if( is_roaming != roaming_cb.previous_value )
 675                 {
 676                         ((network_info_roaming_state_changed_cb)(roaming_cb.cb))(is_roaming, roaming_cb.user_data);
 677                         roaming_cb.previous_value = is_roaming;
 678                 }
 679         }
 680 }
 681
 682
 683 static char* __convert_error_code_to_string(network_info_error_e error_code)
 684 {
 685         switch(error_code)
 686         {
 687                 case NETWORK_INFO_ERROR_OUT_OF_MEMORY:
 688                         return "OUT_OF_MEMORY";
 689                 case NETWORK_INFO_ERROR_INVALID_PARAMETER:
 690                         return "INVALID_PARAMETER";
 691                 case NETWORK_INFO_ERROR_OPERATION_FAILED:
 692                         return "OPERATION_FAILED";
 693                 case NETWORK_INFO_ERROR_OUT_OF_SERVICE:
 694                         return "OUT_OF_SERVICE";
 695                 default:
 696                         return "UNKNOWN";
 697         }
 698 }
 699
 700 static int __check_service_state(char* function_name)
 701 {
 702         network_info_service_state_e service_state = NETWORK_INFO_SERVICE_STATE_OUT_OF_SERVICE;
 703
 704         if( network_info_get_service_state(&service_state) != NETWORK_INFO_ERROR_NONE )
 705         {
 706                 LOGE("[%s] OPERATION_FAILED(0x%08x)", function_name, NETWORK_INFO_ERROR_OPERATION_FAILED);
 707                 return NETWORK_INFO_ERROR_OPERATION_FAILED;
 708         }
 709
 710         if( service_state != NETWORK_INFO_SERVICE_STATE_IN_SERVICE )
 711         {
 712                 LOGE("[%s] OUT_OF_SERVICE(0x%08x)", function_name, NETWORK_INFO_ERROR_OUT_OF_SERVICE);
 713                 return NETWORK_INFO_ERROR_OUT_OF_SERVICE;
 714         }
 715
 716         return NETWORK_INFO_ERROR_NONE;
 717 }
 718
 719
 720