src/FTel_NetworkManagerImpl.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17 /**
  18  * @file        FTel_NetworkManagerImpl.cpp
  19  * @brief       This is the implementation file for _NetworkManagerImpl class.
  20  */
  21
  22 #include <stdlib.h>
  23 #include <net_connection.h>
  24 #include <telephony_network.h>
  25 #include <telephony_network_type.h>
  26 #include <FTelITelephonyNetworkEventListener.h>
  27 #include <FTelITelephonyNetworkSettingListener.h>
  28 #include <FTelNetworkInfo.h>
  29 #include <FTelNetworkStatus.h>
  30 #include <FTelNetworkManager.h>
  31 #include <FSysSettingInfo.h>
  32 #include <FBaseUtilStringUtil.h>
  33 #include <FBaseSysLog.h>
  34 #include "FApp_AppInfo.h"
  35 #include "FTel_NetworkManagerImpl.h"
  36 #include "FTel_NetworkStatusImpl.h"
  37 #include "FTel_NetworkInfoImpl.h"
  38 #include "FTel_NetworkManagerEvent.h"
  39 #include "FTel_NetworkManagerEventArg.h"
  40 #include "FTel_NetworkSettingEvent.h"
  41 #include "FTel_NetworkSettingEventArg.h"
  42 #include "FTel_TelephonyUtility.h"
  43 #include "FTel_TelephonyIpcProxy.h"
  44
  45 using namespace std;
  46 using namespace Tizen::System;
  47 using namespace Tizen::App;
  48 using namespace Tizen::Base;
  49 using namespace Tizen::Base::Utility;
  50 using namespace Tizen::Base::Collection;
  51
  52
  53 namespace Tizen { namespace Telephony
  54 {
  55
  56 _NetworkManagerImpl::_NetworkManagerImpl(void)
  57     : __pNetworkManagerEvent(null)
  58     , __pNetworkSettingEvent(null)
  59     , __pTelephonyServiceProxy(null)
  60     , __pSettingListener(null)
  61         , __isEventAdded(false)
  62 {
  63 }
  64
  65 _NetworkManagerImpl::~_NetworkManagerImpl(void)
  66 {
  67     if ((__pNetworkManagerEvent != null) && __isEventAdded && (__pTelephonyServiceProxy != null))
  68     {
  69                 __pTelephonyServiceProxy->RemoveNetworkEvent(__pNetworkManagerEvent.get());
  70     }
  71 }
  72
  73 result
  74 _NetworkManagerImpl::Construct(ITelephonyNetworkEventListener* pListener)
  75 {
  76         __pTelephonyServiceProxy = _TelephonyIpcProxy::GetInstance();
  77
  78     if (__pTelephonyServiceProxy == null)
  79     {
  80         SysLog(NID_TEL, "Creating an IPC instance to connect with the Connectivity service daemon has failed.");
  81     }
  82
  83     if (pListener != null)
  84     {
  85         unique_ptr<_NetworkManagerEvent> pNetworkManagerEvent(new (std::nothrow) _NetworkManagerEvent);
  86         SysTryReturnResult(NID_TEL, pNetworkManagerEvent != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
  87
  88         result r = pNetworkManagerEvent->Construct();
  89         SysTryReturnResult(NID_TEL,  r != E_OUT_OF_MEMORY, r, "Propagating.");
  90         SysTryReturnResult(NID_TEL,  r == E_SUCCESS, E_SYSTEM, "A system error has occurred. Failed to construct of the _NetworkManagerEvent.");
  91
  92         SysTryReturnResult(NID_TEL,  __pTelephonyServiceProxy != null, E_SYSTEM, "Failed to initialize the telephony ipc client.");
  93         r = __pTelephonyServiceProxy->AddNetworkEvent(pNetworkManagerEvent.get());
  94         SysTryReturnResult(NID_TEL,  r == E_SUCCESS, r, "Propagating.");
  95
  96         __isEventAdded = true;
  97
  98         pNetworkManagerEvent->AddListener(*pListener, true);
  99
 100         __pNetworkManagerEvent = move(pNetworkManagerEvent);
 101     }
 102
 103     return E_SUCCESS;
 104 }
 105
 106 result
 107 _NetworkManagerImpl::GetNetworkStatus(NetworkStatus& networkStatus) const
 108 {
 109     bool isRoaming = false;
 110     bool isDataServiceAvailable = false;
 111     bool isCallServiceAvailable = false;
 112
 113     SysTryReturnResult(NID_TEL, IsNetworkAvailable(), E_NETWORK_UNAVAILABLE, "The operation has failed because the device is in the offline mode.");
 114
 115     // Get the isRoming
 116     isRoaming = IsRoaming();
 117
 118    // Get the isCallServiceAvailable
 119         SysTryReturnResult(NID_TEL, IsServiceAvailable(), E_SERVICE_UNAVAILABLE, "The operation failed because the device is out of the coverage area or in the emergency mode.")
 120         isCallServiceAvailable = true;
 121
 122         isDataServiceAvailable = IsDataAvailable();
 123
 124     _NetworkStatusImpl::GetInstance(networkStatus)->SetIsRoaming(isRoaming);
 125     _NetworkStatusImpl::GetInstance(networkStatus)->SetIsCallServiceAvailable(isCallServiceAvailable);
 126     _NetworkStatusImpl::GetInstance(networkStatus)->SetIsDataServiceAvailable(isDataServiceAvailable);
 127
 128         return E_SUCCESS;
 129 }
 130
 131 result
 132 _NetworkManagerImpl::GetNetworkInfo(NetworkInfo& networkInfo) const
 133 {
 134         result r = E_SUCCESS;
 135
 136     SysTryReturnResult(NID_TEL, IsNetworkAvailable(), E_NETWORK_UNAVAILABLE,
 137                                       "The operation has failed because the device is in the offline mode.");
 138     SysTryReturnResult(NID_TEL, IsServiceAvailable(), E_SERVICE_UNAVAILABLE,
 139                                       "The operation failed because the device is out of the coverage area or in the emergency mode.");
 140
 141     int err = NETWORK_INFO_ERROR_NONE;
 142     _ApiVersion apiVersion = _AppInfo::GetApiVersion();
 143
 144     // Get the cell ID
 145     int cellId = -1;
 146     err = network_info_get_cell_id(&cellId);
 147         SysLog(NID_TEL, "The return value of network_info_get_cell_id() is %d and the cellId value is %d", err, cellId);
 148     SysTryReturnResult(NID_TEL, err == NETWORK_INFO_ERROR_NONE, E_SYSTEM, "A system error has occurred. Failed to get the cell ID.");
 149
 150     // Get the lac
 151     int lac = -1;
 152     err = network_info_get_lac(&lac);
 153         SysLog(NID_TEL, "The return value of network_info_get_lac() is %d and the lac value is %d", err, lac);
 154     SysTryReturnResult(NID_TEL, err == NETWORK_INFO_ERROR_NONE, E_SYSTEM, "A system error has occurred. Failed to get the lac.");
 155
 156         char* pTemp = null;
 157
 158     // Get the operator name
 159     err = network_info_get_provider_name(&pTemp);
 160     SysTryReturnResult(NID_TEL, err == NETWORK_INFO_ERROR_NONE, E_SYSTEM, "A system error has occurred. Failed to get the plmn.");
 161     unique_ptr<char[],_CharDeleter> pOperatorName(pTemp);
 162     String operatorName;
 163     r = (StringUtil::Utf8ToString(pOperatorName.get(), operatorName));
 164     SysTryReturnResult(NID_TEL, r != E_OUT_OF_MEMORY, r, "Propagating.");
 165         SysLog(NID_TEL, "The operatorname is %ls", operatorName.GetPointer());
 166
 167     // Get the mcc
 168     err = network_info_get_mcc(&pTemp);
 169         SysLog(NID_TEL, "The return value of network_info_get_mcc() is %d and the mcc value is %s", err, pTemp);
 170     SysTryReturnResult(NID_TEL, err == NETWORK_INFO_ERROR_NONE, E_SYSTEM, "A system error has occurred. Failed to get the mcc.");
 171     unique_ptr<char[],_CharDeleter> pMcc(pTemp);
 172
 173     // Get the mnc
 174     err = network_info_get_mnc(&pTemp);
 175         SysLog(NID_TEL, "The return value of network_info_get_mnc() is %d and the mnc value is %s", err, pTemp);
 176     SysTryReturnResult(NID_TEL, err == NETWORK_INFO_ERROR_NONE, E_SYSTEM, "A system error has occurred. Failed to get the mnc.");
 177     unique_ptr<char[],_CharDeleter> pMnc(pTemp);
 178
 179     String plmn;
 180     r = plmn.Append(pMcc.get());
 181     SysTryReturnResult(NID_TEL, r == E_SUCCESS, E_SYSTEM, "A system error has occurred. Failed to set plmn.");
 182
 183     r = plmn.Append(pMnc.get());
 184         SysLog(NID_TEL, "The plmn value is %ls", plmn.GetPointer());
 185     SysTryReturnResult(NID_TEL, r == E_SUCCESS, E_SYSTEM, "A system error has occurred. Failed to set plmn.");
 186
 187     _NetworkInfoImpl::GetInstance(networkInfo)->SetCellId(cellId);
 188     _NetworkInfoImpl::GetInstance(networkInfo)->SetLac(lac);
 189     _NetworkInfoImpl::GetInstance(networkInfo)->SetOperatorName(operatorName);
 190     _NetworkInfoImpl::GetInstance(networkInfo)->SetMcc(atoi(pMcc.get()));
 191     _NetworkInfoImpl::GetInstance(networkInfo)->SetMnc(atoi(pMnc.get()));
 192
 193     if (apiVersion == _API_VERSION_2_0 && _AppInfo::IsOspCompat())
 194     {
 195         _NetworkInfoImpl::GetInstance(networkInfo)->SetPlmn(operatorName);
 196     }
 197     else
 198     {
 199         _NetworkInfoImpl::GetInstance(networkInfo)->SetPlmn(plmn);
 200     }
 201
 202     return E_SUCCESS;
 203 }
 204
 205 result
 206 _NetworkManagerImpl::SetNetworkSettingListener(ITelephonyNetworkSettingListener* pListener)
 207 {
 208     SysTryReturnResult(NID_TEL, __pTelephonyServiceProxy != null, E_SYSTEM, "A system error has occurred. IPC instance has not been constructed yet.");
 209
 210     result r = __pTelephonyServiceProxy->HasSystemPrivilege();
 211     SysTryReturnResult(NID_TEL, r == E_SUCCESS, r, "Propagating.");
 212
 213     if (__pSettingListener != null)
 214     {
 215         __pNetworkSettingEvent->RemoveListener(*__pSettingListener);
 216         __pSettingListener = null;
 217     }
 218
 219     // Creates event object
 220     if (__pNetworkSettingEvent == null && pListener != null)
 221     {
 222         std::unique_ptr<_NetworkSettingEvent> pNetworkSettingEvent(new (std::nothrow) _NetworkSettingEvent());
 223
 224          SysTryReturnResult(NID_TEL, pNetworkSettingEvent != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
 225
 226          r = pNetworkSettingEvent->Construct();
 227          SysTryReturnResult(NID_TEL, r == E_SUCCESS, r, "Propagating.");
 228
 229          __pNetworkSettingEvent = move(pNetworkSettingEvent);
 230     }
 231
 232     // Adds listener
 233     if (pListener != null)
 234     {
 235         __pSettingListener = pListener;
 236         r = __pNetworkSettingEvent->AddListener(*__pSettingListener, true);
 237     }
 238
 239     if (r != E_SUCCESS)
 240     {
 241         __pNetworkSettingEvent.reset(null);
 242                 SysLogException(NID_TEL, r, "[%s] Propagating.", GetErrorMessage(r));
 243     }
 244
 245     return r;
 246 }
 247
 248 result
 249 _NetworkManagerImpl::GetNetworkSelectionMode(void)
 250 {
 251     SysTryReturnResult(NID_TEL, __pTelephonyServiceProxy != null, E_SYSTEM, "A system error has occurred. IPC instance has not been constructed yet.");
 252
 253     result r = __pTelephonyServiceProxy->GetNetworkSelectionMode(this);
 254     SysTryReturnResult(NID_TEL, r != E_OUT_OF_MEMORY, r, "Propagating.");
 255     SysTryReturnResult(NID_TEL, r != E_PRIVILEGE_DENIED, r, "Propagating.");
 256     SysTryReturnResult(NID_TEL, r == E_SUCCESS, E_OPERATION_FAILED, "Failed to get selection mode.");
 257
 258     return r;
 259 }
 260
 261 result
 262 _NetworkManagerImpl::SelectNetwork(const NetworkInfo & networkInfo)
 263 {
 264     SysTryReturnResult(NID_TEL, __pTelephonyServiceProxy != null, E_SYSTEM, "IPC instance has not been constructed yet.");
 265
 266     const _NetworkInfoImpl* pNetworkInfoImpl = _NetworkInfoImpl::GetInstance(networkInfo);
 267     TelNetworkSystemType_t networkSystemType = _TelephonyUtility::ConvertNetworkType(pNetworkInfoImpl->GetNetworkType());
 268
 269     result r = __pTelephonyServiceProxy->SelectNetwork(this, pNetworkInfoImpl->GetPlmn(), (int)networkSystemType);
 270     SysTryReturnResult(NID_TEL, r != E_OUT_OF_MEMORY, r, "Propagating.");
 271     SysTryReturnResult(NID_TEL, r != E_PRIVILEGE_DENIED, r, "Propagating.");
 272     SysTryReturnResult(NID_TEL, r == E_SUCCESS, E_OPERATION_FAILED, "Failed to select network manually.");
 273
 274     return r;
 275 }
 276
 277 result
 278 _NetworkManagerImpl::SelectNetwork(void)
 279 {
 280     SysTryReturnResult(NID_TEL, __pTelephonyServiceProxy != null, E_SYSTEM, "A system error has occurred. IPC instance has not been constructed yet.");
 281
 282     result r = __pTelephonyServiceProxy->SelectNetwork(this);
 283     SysTryReturnResult(NID_TEL, r != E_OUT_OF_MEMORY, r, "Propagating.");
 284     SysTryReturnResult(NID_TEL, r != E_PRIVILEGE_DENIED, r, "Propagating.");
 285     SysTryReturnResult(NID_TEL, r == E_SUCCESS, E_OPERATION_FAILED, "Failed to select network automatically.");
 286
 287     return r;
 288 }
 289
 290 result
 291 _NetworkManagerImpl::SearchNetwork(void)
 292 {
 293     SysTryReturnResult(NID_TEL, __pTelephonyServiceProxy != null, E_SYSTEM, "A system error has occurred. IPC instance has not been constructed yet.");
 294
 295     result r = __pTelephonyServiceProxy->SearchNetwork(this);
 296     SysTryReturnResult(NID_TEL, r != E_OUT_OF_MEMORY, r, "Propagating.");
 297     SysTryReturnResult(NID_TEL, r != E_PRIVILEGE_DENIED, r, "Propagating.");
 298     SysTryReturnResult(NID_TEL, r == E_SUCCESS, E_OPERATION_FAILED, "Failed to search network automatic.");
 299
 300     return r;
 301 }
 302
 303 bool
 304 _NetworkManagerImpl::IsDataAvailable(void) const
 305 {
 306     connection_h pConnHandle = null;
 307     connection_cellular_state_e dataServiceState = CONNECTION_CELLULAR_STATE_OUT_OF_SERVICE;
 308     bool isDataAvailable = false;
 309     int err = connection_create(&pConnHandle);
 310     SysLog(NID_TEL, "The return value of connection_create() is %d", err);
 311     SysTryReturn(NID_TEL, err == CONNECTION_ERROR_NONE, false, E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to get the connection handle.");
 312     std::unique_ptr<void, _ConnectionDeleter> pConnectionHandle(pConnHandle);
 313
 314     err = connection_get_cellular_state(pConnHandle, &dataServiceState);
 315
 316     SysLog(NID_TEL, "The return value of connection_get_cellular_state() is 0x%x and the dataServiceState is %d", err, dataServiceState);
 317
 318     if (dataServiceState == CONNECTION_CELLULAR_STATE_AVAILABLE || dataServiceState == CONNECTION_CELLULAR_STATE_CONNECTED)
 319     {
 320         isDataAvailable = true;
 321     }
 322     else
 323     {
 324         isDataAvailable = false;
 325     }
 326
 327     return isDataAvailable;
 328 }
 329
 330 bool
 331 _NetworkManagerImpl::IsRoaming(void) const
 332 {
 333     int err = NETWORK_INFO_ERROR_NONE;
 334     bool isRoaming = false;
 335
 336     err = network_info_is_roaming(&isRoaming);
 337     SysLog(NID_TEL, "The return value of network_info_is_roaming() is 0x%x and the roming state is %s", err, isRoaming ? "True" : "False");
 338
 339     return isRoaming;
 340 }
 341
 342 bool
 343 _NetworkManagerImpl::IsServiceAvailable(bool checkEmergency /* = false */)
 344 {
 345     bool isAvailable = false;
 346     int err = NETWORK_INFO_ERROR_NONE;
 347     network_info_service_state_e state;
 348
 349     err = network_info_get_service_state(&state);
 350         SysLog(NID_TEL, "The return value of network_info_get_service_state() is 0x%x and the state is %d and checkEmergency is %s",
 351                 err, state, checkEmergency ? "True" : "False");
 352
 353     if (!checkEmergency && state == NETWORK_INFO_SERVICE_STATE_IN_SERVICE)
 354     {
 355         isAvailable = true;
 356     }
 357     else if (checkEmergency && (state == NETWORK_INFO_SERVICE_STATE_IN_SERVICE ||
 358                                                                             state == NETWORK_INFO_SERVICE_STATE_EMERGENCY_ONLY))
 359     {
 360         isAvailable = true;
 361     }
 362
 363     return isAvailable;
 364 }
 365
 366 bool
 367 _NetworkManagerImpl::IsNetworkAvailable(void)
 368 {
 369     bool isFlightModeEnabled = false;
 370     result r = SettingInfo::GetValue(L"http://tizen.org/setting/network.flight_mode", isFlightModeEnabled);
 371         SysLog(NID_TEL, "isFlightModeEnabled is %s", isFlightModeEnabled ? "True":"False");
 372         SysLog(NID_TEL, "The return value of SettingInfo::GetValue() is %s", GetErrorMessage(r));
 373
 374         if (r != E_SUCCESS)
 375         {
 376             return false;
 377         }
 378
 379     return !isFlightModeEnabled;
 380 }
 381
 382 _NetworkManagerImpl*
 383 _NetworkManagerImpl::GetInstance(NetworkManager& networkManager)
 384 {
 385     return networkManager.__pNetworkManagerImpl;
 386 }
 387
 388 const _NetworkManagerImpl*
 389 _NetworkManagerImpl::GetInstance(const NetworkManager& networkManager)
 390 {
 391     return networkManager.__pNetworkManagerImpl;
 392 }
 393
 394
 395 void
 396 _NetworkManagerImpl::OnTelephonyNetworkSelectionModeReceived(bool isManual, result r)
 397 {
 398         SysLog(NID_TEL, "The mode is %s and the result is %s", isManual ? "Manual":"Automatic", GetErrorMessage(r));
 399
 400     if (__pNetworkSettingEvent != null)
 401     {
 402         _NetworkSettingEventArg* pEventArg = new (std::nothrow)_NetworkSettingEventArg(_NETWORK_EVENT_GET_SELECTION_MODE, isManual, r);
 403         SysTryReturnVoidResult(NID_TEL, pEventArg != null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 404         (void)__pNetworkSettingEvent->Fire(*pEventArg);
 405     }
 406 }
 407
 408 void
 409 _NetworkManagerImpl::OnTelephonyNetworkSelectionCompleted(result r)
 410 {
 411         SysLog(NID_TEL, "The listener has called with the result %s", GetErrorMessage(r));
 412
 413     if (__pNetworkSettingEvent != null)
 414     {
 415         _NetworkSettingEventArg* pEventArg = new (std::nothrow)_NetworkSettingEventArg(_NETWORK_EVENT_SELECT_NETWORK, r);
 416         SysTryReturnVoidResult(NID_TEL, pEventArg != null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 417         (void)__pNetworkSettingEvent->Fire(*pEventArg);
 418     }
 419 }
 420
 421 void
 422 _NetworkManagerImpl::OnTelephonyNetworkSearchCompleted(String message, result r)
 423 {
 424         SysLog(NID_TEL, "The listener has called with the result %s", GetErrorMessage(r));
 425
 426     if (__pNetworkSettingEvent != null)
 427     {
 428         IList* pNetworkInfoList = null;
 429
 430         if (r == E_SUCCESS)
 431         {
 432             pNetworkInfoList = ParsingMessageN(message);
 433
 434             if (pNetworkInfoList == null)
 435             {
 436                 SysLog(NID_TEL, "ParsingMessageN() has failed ");
 437                 r = E_SYSTEM;
 438             }
 439         }
 440
 441         _NetworkSettingEventArg* pEventArg = new (std::nothrow)_NetworkSettingEventArg(_NETWORK_EVENT_SEARCH_COMPLETED, pNetworkInfoList, r);
 442         SysTryReturnVoidResult(NID_TEL, pEventArg != null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 443
 444         (void)__pNetworkSettingEvent->Fire(*pEventArg);
 445     }
 446 }
 447
 448 IList*
 449 _NetworkManagerImpl::ParsingMessageN(const String& message)
 450 {
 451     result r = E_SUCCESS;
 452     int currentIndex = 0;
 453     String temp;
 454
 455     NetworkInfo* pNetworkInfo = null;
 456
 457     int networkInfoCount = 0;
 458
 459     r = message.SubString(0, 1, temp);
 460         SysTryReturn(NID_TEL, r == E_SUCCESS, null, E_SYSTEM, "[%s] A system error has occurred.", GetErrorMessage(E_SYSTEM));
 461
 462     temp.Trim();
 463
 464     r = Integer::Decode(temp, networkInfoCount);
 465         SysTryReturn(NID_TEL, r == E_SUCCESS, null, E_SYSTEM, "[%s] A system error has occurred.", GetErrorMessage(E_SYSTEM));
 466
 467     ArrayList* pNetworkInfoList = null;
 468
 469     pNetworkInfoList = new (std::nothrow) ArrayList();
 470         SysTryReturn(NID_TEL, pNetworkInfoList != null, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 471
 472     r = pNetworkInfoList->Construct(networkInfoCount);
 473     SysTryReturn(NID_TEL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 474
 475     for (int i = 0 ; i < networkInfoCount ; i++)
 476     {
 477         pNetworkInfo = GenerateNetworkInfoN(message, currentIndex);
 478
 479         pNetworkInfoList->Add(*pNetworkInfo);
 480     }
 481
 482     return pNetworkInfoList;
 483
 484 }
 485
 486 NetworkInfo*
 487 _NetworkManagerImpl::GenerateNetworkInfoN(const String& message, int& currentIndex)
 488 {
 489     NetworkInfo* pNetworkInfo = null;
 490     _NetworkInfoImpl* pNetworkInfoImpl = null;
 491
 492     int temp = 0;
 493     String tempString;
 494
 495     pNetworkInfo = new (std::nothrow) NetworkInfo();
 496     SysTryReturn(NID_TEL, pNetworkInfo != null, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 497
 498     pNetworkInfoImpl = _NetworkInfoImpl::GetInstance(*pNetworkInfo);
 499
 500     // PLMN
 501     int mcc = -1;
 502     int mnc = -1;
 503     tempString = MessageWithLengthToString(message, currentIndex);
 504     _TelephonyUtility::GetMccMncFromPlmn(tempString, mcc, mnc);
 505     pNetworkInfoImpl->SetPlmn(tempString);
 506     pNetworkInfoImpl->SetMcc(mcc);
 507     pNetworkInfoImpl->SetMnc(mnc);
 508     SysLog(NID_TEL, "The plmn value is %ls, the mcc value is %d and the mnc is %d",tempString.GetPointer(), mcc, mnc);
 509
 510     // Operator Name
 511     tempString = MessageWithLengthToString(message, currentIndex);
 512     pNetworkInfoImpl->SetOperatorName(tempString);
 513     SysLog(NID_TEL, "The Operator Name is %ls", tempString.GetPointer());
 514
 515     // NetworkType
 516     tempString = MessageToString(message, currentIndex);
 517     Tizen::Base::Integer::Parse(tempString, temp);
 518
 519     _NetworkType networkType = _TelephonyUtility::ConvertNetworkType(static_cast<TelNetworkSystemType_t>(temp));
 520     pNetworkInfoImpl->SetNetworkType(networkType);
 521     SysLog(NID_TEL, "The NetworkType is %d", networkType);
 522
 523     return pNetworkInfo;
 524 }
 525
 526
 527 String
 528 _NetworkManagerImpl::MessageToString(const String& message, int& currentIndex)
 529 {
 530     int nextIndex = 0;
 531     String tempString;
 532     result r = E_SUCCESS;
 533
 534     r = message.IndexOf(":", currentIndex, nextIndex);
 535
 536     if (r != E_SUCCESS)
 537     {
 538         SysLog(NID_TEL, "The result of message.IndexOf is %s", GetErrorMessage(r));
 539     }
 540
 541     currentIndex = nextIndex + 1;
 542
 543     r = message.IndexOf(":", currentIndex, nextIndex);
 544
 545     if (r != E_SUCCESS)
 546     {
 547         SysLog(NID_TEL, "The result of message.IndexOf is %s", GetErrorMessage(r));
 548     }
 549
 550     r = message.SubString(currentIndex, nextIndex-currentIndex, tempString);
 551
 552     if (r != E_SUCCESS)
 553     {
 554         SysLog(NID_TEL, "The result of message.SubString is %s", GetErrorMessage(r));
 555     }
 556
 557     return tempString;
 558 }
 559
 560 String
 561 _NetworkManagerImpl::MessageWithLengthToString(const String& message, int& currentIndex)
 562 {
 563     // e.g. plmn or network name -> "05Olleh",
 564     int nextIndex = 0;
 565     String tempString("");
 566     result r = E_SUCCESS;
 567     int len = 0;
 568
 569     r = message.IndexOf(":", currentIndex, nextIndex);
 570
 571     if (r != E_SUCCESS)
 572     {
 573         SysLog(NID_TEL, "The result of message.IndexOf is %s", GetErrorMessage(r));
 574     }
 575
 576     currentIndex = nextIndex + 1;
 577
 578     message.SubString(currentIndex, 2, tempString);
 579     tempString.Trim();
 580     currentIndex += 2;
 581     Tizen::Base::Integer::Decode(tempString, static_cast<int&>(len));
 582
 583     if (len == 0)
 584     {
 585         tempString = "";
 586     }
 587     else
 588     {
 589         r = message.SubString(currentIndex, len, tempString);
 590
 591         if (r != E_SUCCESS)
 592         {
 593             SysLog(NID_TEL, "The result of message.IndexOf is %s", GetErrorMessage(r));
 594         }
 595     }
 596
 597     currentIndex += len;
 598
 599     return tempString;
 600 }
 601
 602 }} // Tizen::Telephony