cellular/telephonysettings/src/PsetNetwork.cpp
changeset 46 2fa1fa551b0b
parent 42 35488577e233
child 48 78df25012fda
equal deleted inserted replaced
42:35488577e233 46:2fa1fa551b0b
     1 /*
       
     2 * Copyright (c) 2002-2005 Nokia Corporation and/or its subsidiary(-ies). 
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description:  CPsetNetwork selects network and gets network information.
       
    15 *
       
    16 *
       
    17 */
       
    18 
       
    19 
       
    20 //  INCLUDE FILES
       
    21 #include "mpsetnetworkinfoobs.h" 
       
    22 #include "psetnetwork.h" 
       
    23 #include "psetsaobserver.h" 
       
    24 #include "psetpanic.h" 
       
    25 #include "psetconstants.h" 
       
    26 #include "mpsetnetworkselect.h" 
       
    27 #include <etelmm.h>
       
    28 #include <mmretrieve.h>
       
    29 #include <rmmcustomapi.h>
       
    30 
       
    31 #include <e32svr.h>
       
    32 #include "phonesettingslogger.h" 
       
    33 
       
    34 //  LOCAL CONSTANTS AND MACROS  
       
    35 _LIT( KPSNameOfClass, "CPsetNetwork" );
       
    36 
       
    37 enum TActiveObserver
       
    38     {
       
    39     ENetSelectObserver,
       
    40     ENetModeObserver
       
    41     };
       
    42 
       
    43 //  MEMBER FUNCTIONS
       
    44 //=============================================================================
       
    45 // ---------------------------------------------------------------------------
       
    46 // 
       
    47 // 1st phase constructor.
       
    48 // 
       
    49 // ---------------------------------------------------------------------------
       
    50 //
       
    51 EXPORT_C CPsetNetwork* CPsetNetwork::NewL( RMobilePhone& aPhone, 
       
    52     MPsetNetworkInfoObserver& aObserver )
       
    53     {
       
    54     CPsetNetwork* self = new ( ELeave ) CPsetNetwork( aPhone );
       
    55     CleanupStack::PushL( self );
       
    56     self->ConstructL( aObserver );
       
    57     CleanupStack::Pop( self );
       
    58     return self;
       
    59     }
       
    60 
       
    61 
       
    62 // ---------------------------------------------------------------------------
       
    63 // 
       
    64 // 1st phase constructor for net mode observer.
       
    65 // 
       
    66 // ---------------------------------------------------------------------------
       
    67 //
       
    68 EXPORT_C CPsetNetwork* CPsetNetwork::NewL( RMobilePhone& aPhone, 
       
    69                        MPsetNetworkModeObserver& aModeObserver )
       
    70     {
       
    71     CPsetNetwork* self = new ( ELeave ) CPsetNetwork( aPhone );
       
    72     CleanupStack::PushL( self );
       
    73     self->ConstructL( aModeObserver );
       
    74     CleanupStack::Pop( self );
       
    75     return self;
       
    76     }
       
    77 
       
    78 
       
    79 // ---------------------------------------------------------------------------
       
    80 // 
       
    81 // Destructor.
       
    82 // 
       
    83 // ---------------------------------------------------------------------------
       
    84 //
       
    85 EXPORT_C CPsetNetwork::~CPsetNetwork()
       
    86     {
       
    87     Cancel();
       
    88     iCustomPhone.Close();
       
    89     delete iNetworkRetrieve;
       
    90     iNetworkRetrieve = NULL;
       
    91     delete iSAObserver;
       
    92     iSAObserver = NULL;    
       
    93     } 
       
    94 
       
    95 // ---------------------------------------------------------------------------
       
    96 // 
       
    97 // Returns available networks
       
    98 // 
       
    99 // ---------------------------------------------------------------------------
       
   100 //
       
   101 EXPORT_C void CPsetNetwork::GetAvailableNetworksL()
       
   102     {
       
   103     __PHSLOGSTRING("[PHS]--> CPsetNetwork::GetAvailableNetworksL");
       
   104     if ( IsActive() )
       
   105         {
       
   106         User::Leave( KErrInUse );
       
   107         }
       
   108 
       
   109     if ( iNetworkRetrieve )
       
   110         {
       
   111         delete iNetworkRetrieve;
       
   112         iNetworkRetrieve = NULL;
       
   113         }
       
   114     
       
   115     // Start to request for network information.
       
   116     iNetworkRetrieve = CRetrieveMobilePhoneDetectedNetworks::NewL( iPhone );
       
   117     iNetworkRetrieve->StartV2( iStatus );    
       
   118     iServiceRequest = MPsetNetworkInfoObserver::EServiceRequestGetNetworkInfo;
       
   119     SetActive();
       
   120     
       
   121     // Show searching note.
       
   122     CleanupLeavePushL();
       
   123     iObserver->HandleSearchingNetworksL( iServiceRequest );
       
   124     CleanupStack::Pop(); // CleanupCancelPushL
       
   125     __PHSLOGSTRING("[PHS] <--CPsetNetwork::GetAvailableNetworksL");
       
   126     }
       
   127 
       
   128 // ---------------------------------------------------------------------------
       
   129 // 
       
   130 // Returns information of the currently selected network.
       
   131 // DEPRECATED.
       
   132 // ---------------------------------------------------------------------------
       
   133 //
       
   134 EXPORT_C TInt CPsetNetwork::GetCurrentNetworkInfo
       
   135                 ( MPsetNetworkSelect::TCurrentNetworkInfo& /*aInfo*/ )
       
   136     {
       
   137     return KErrNotSupported;
       
   138     }
       
   139 
       
   140 // ---------------------------------------------------------------------------
       
   141 // 
       
   142 // Retrieve current search mode (automatic or manual)
       
   143 // 
       
   144 // ---------------------------------------------------------------------------
       
   145 //
       
   146 EXPORT_C TInt CPsetNetwork::GetNetworkSelectMode( TSelectMode& aMode )
       
   147     {
       
   148     /*****************************************************
       
   149     *    Series 60 Customer / ETel
       
   150     *    Series 60  ETel API
       
   151     *****************************************************/
       
   152     RMobilePhone::TMobilePhoneNetworkSelectionV1 setMode;
       
   153     RMobilePhone::TMobilePhoneNetworkSelectionV1Pckg setModePckg( setMode );
       
   154     
       
   155     __PHSLOGSTRING("[PHS]--> CPsetNetwork::GetNetworkSelectMode");
       
   156 
       
   157     TInt res( iPhone.GetNetworkSelectionSetting( setModePckg ) );
       
   158     
       
   159     if ( res == KErrNone )
       
   160         {
       
   161         if ( setMode.iMethod == RMobilePhone::ENetworkSelectionAutomatic )
       
   162             {
       
   163             aMode = ENetSelectModeAutomatic;
       
   164             }
       
   165         else
       
   166             {
       
   167             aMode = ENetSelectModeManual;
       
   168             }
       
   169         iTempNetInfo.iMode = aMode;
       
   170         }
       
   171     __PHSLOGSTRING("[PHS] <--CPsetNetwork::GetNetworkSelectMode");
       
   172     return res;
       
   173     }
       
   174 
       
   175 // ---------------------------------------------------------------------------
       
   176 // 
       
   177 // Starts using the indicated network.
       
   178 // 
       
   179 // ---------------------------------------------------------------------------
       
   180 //
       
   181 EXPORT_C void CPsetNetwork::SelectNetworkL( const TNetworkInfo& aInfo )
       
   182     {
       
   183     __PHSLOGSTRING("[PHS]--> CPsetNetwork::SelectNetworkL");
       
   184     if ( IsActive() )
       
   185         {
       
   186         User::Leave( KErrInUse );
       
   187         }    
       
   188 
       
   189     //Save previous network mode.
       
   190     TBool previousModeAutomatic = EFalse;
       
   191     if ( iTempNetInfo.iMode == ENetSelectModeAutomatic )
       
   192         {
       
   193         previousModeAutomatic = ETrue;
       
   194         }
       
   195     iTempNetInfo = aInfo;
       
   196 
       
   197     /*****************************************************
       
   198     *    Series 60 Customer / ETel
       
   199     *    Series 60  ETel API
       
   200     *****************************************************/
       
   201     if ( aInfo.iMode == ENetSelectModeManual )
       
   202         {        
       
   203         //Copy data to member variables and make a request.
       
   204         iNwInfo.iCountry.Append( aInfo.iId.iCountryCode );
       
   205         __PHSLOGSTRING1("[PHS]   CPsetNetwork::SelectNetworkL: Manual - CountryCode: %S", &aInfo.iId.iCountryCode);
       
   206 
       
   207         iNwInfo.iNetwork.Append( aInfo.iId.iNetworkCode );        
       
   208         __PHSLOGSTRING1("[PHS]   CPsetNetwork::SelectNetworkL: Manual - NetworkCode: %S", &aInfo.iId.iNetworkCode);
       
   209 
       
   210         iServiceRequest = MPsetNetworkInfoObserver::EServiceRequestSetNetwork;
       
   211         iPhone.SelectNetwork( iStatus, ETrue, iNwInfo );
       
   212         }
       
   213     else
       
   214         {
       
   215         iServiceRequest = 
       
   216             MPsetNetworkInfoObserver::EServiceRequestSetNetworkAutomatic;
       
   217         //If previously automatic, and now automatic, issue request
       
   218         // to search networks.
       
   219         if ( previousModeAutomatic )
       
   220             {
       
   221             iNwInfo.iCountry.Append( aInfo.iId.iCountryCode );            
       
   222             __PHSLOGSTRING1("[PHS]   CPsetNetwork::SelectNetworkL: Auto - CountryCode: %S", &aInfo.iId.iCountryCode);
       
   223 
       
   224             iNwInfo.iNetwork.Append( aInfo.iId.iNetworkCode );
       
   225             __PHSLOGSTRING1("[PHS]   CPsetNetwork::SelectNetworkL: Auto - NetworkCode: %S", &aInfo.iId.iNetworkCode);
       
   226 
       
   227             iPhone.SelectNetwork( iStatus, EFalse, iNwInfo );
       
   228             }
       
   229         // make new selection without Network/Country code this way device 
       
   230         // connects automatically home network.
       
   231         else
       
   232             {    
       
   233             iNwInfo.iCountry = KNullDesC;
       
   234             iNwInfo.iNetwork = KNullDesC;
       
   235             __PHSLOGSTRING("[PHS]   CPsetNetwork::SelectNetworkL: Manual>Auto - CountryCode = KNullDesC");
       
   236             __PHSLOGSTRING("[PHS]   CPsetNetwork::SelectNetworkL: Manual>Auto - NetworkCode = KNullDesC");
       
   237             iPhone.SelectNetwork( iStatus, EFalse, iNwInfo );
       
   238             }
       
   239         }    
       
   240     SetActive();
       
   241     
       
   242     //Show requesting note.
       
   243     CleanupLeavePushL();    
       
   244     if ( aInfo.iMode == ENetSelectModeManual )
       
   245         {
       
   246         __PHSLOGSTRING("[PHS]--> CPsetNetwork::SelectNetworkL: Requesting Selected N/W");
       
   247         iObserver->HandleRequestingSelectedNetworkL( ETrue );
       
   248         }
       
   249     else
       
   250         {
       
   251         __PHSLOGSTRING("[PHS]--> CPsetNetwork::SelectNetworkL: Searching N/Ws");
       
   252         iObserver->HandleSearchingNetworksL( iServiceRequest );
       
   253         }    
       
   254     CleanupStack::Pop(); // CleanupCancelPushL
       
   255     __PHSLOGSTRING("[PHS] <--CPsetNetwork::SelectNetworkL");
       
   256     }
       
   257 
       
   258 // ---------------------------------------------------------------------------
       
   259 // 
       
   260 // Running the active object
       
   261 // 
       
   262 // ---------------------------------------------------------------------------
       
   263 //
       
   264 void CPsetNetwork::RunL()
       
   265     {
       
   266     __PHSLOGSTRING1("[PHS]--> CPsetNetwork::RunL() - iStatus = %d", iStatus.Int());
       
   267 
       
   268     MPsetNetworkInfoObserver::TServiceRequest serviceRequest = iServiceRequest;
       
   269     MPsetNetworkModeObserver::TServiceRequest modeRequest = iModeRequest;
       
   270 
       
   271     // Params have to be cleared here since the observer may initiate another asynchronous operation immediately
       
   272     // after they are notified, effectively messing up the state machine which controls the logic in DoCancel()
       
   273     // resulting in a possible dead lock when CActive::Cancel()'s User::WaitForRequest( iStatus ) never gets signaled.
       
   274     ClearParams();
       
   275     
       
   276     if ( iActiveObserver == ENetSelectObserver && iObserver )
       
   277         {
       
   278         __ASSERT_ALWAYS( iObserver, Panic( KPSNameOfClass, ENetNoObserver ) );
       
   279         HideRequestNoteL();
       
   280         }
       
   281     else if ( iActiveObserver == ENetModeObserver && iNetworkModeObserver )
       
   282         {        
       
   283         __ASSERT_ALWAYS( iNetworkModeObserver, 
       
   284                      Panic( KPSNameOfClass, ENetNoNetworkObserver  ) );
       
   285         }
       
   286         
       
   287     if ( iStatus != KErrNone )
       
   288         {
       
   289         if ( modeRequest == 
       
   290               MPsetNetworkModeObserver::EServiceRequestSetSelectedNetworkMode || 
       
   291              modeRequest == 
       
   292               MPsetNetworkModeObserver::EServiceRequestGetCurrentNetworkMode )
       
   293             {
       
   294             __PHSLOGSTRING("[PHS]--> CPsetNetwork::RunL: Request is modeRequest");
       
   295             //PSetNetworkModeObs
       
   296             iNetworkModeObserver->HandleNetworkErrorL( modeRequest, iStatus.Int() );
       
   297             }
       
   298         else
       
   299             {
       
   300             __PHSLOGSTRING("[PHS]--> CPsetNetwork::RunL: Request is serviceRequest");
       
   301             //PSetNetworkInfoObs
       
   302             GetRegistrationStatusL();
       
   303             iObserver->HandleNetworkErrorL( serviceRequest, iStatus.Int() );
       
   304             }
       
   305         } 
       
   306     else // Request completed successfully.
       
   307         {
       
   308         switch ( serviceRequest )
       
   309             {
       
   310             case MPsetNetworkInfoObserver::EServiceRequestGetNetworkInfo:
       
   311                 {
       
   312                 CNetworkInfoArray* array = new ( ELeave ) 
       
   313                     CNetworkInfoArray( KPSetNetworkInfoArrayGranularity );
       
   314                 CleanupStack::PushL( array );
       
   315 
       
   316                 CMobilePhoneNetworkListV2* results = 
       
   317                     iNetworkRetrieve->RetrieveListV2L();
       
   318                 CleanupStack::PushL( results );
       
   319                 TInt amount = results->Enumerate();
       
   320                 __PHSLOGSTRING1("[PHS]   CPsetNetwork::RunL: amount: %d", amount);
       
   321                 TInt i = 0;
       
   322                 /*****************************************************
       
   323                 *    Series 60 Customer / ETel
       
   324                 *    Series 60  ETel API
       
   325                 *****************************************************/
       
   326                 RMobilePhone::TMobilePhoneNetworkInfoV2 nwNames;
       
   327                 while ( amount > i ) 
       
   328                     {
       
   329                     nwNames = results->GetEntryL( i );
       
   330                     iTempNetInfo.iId.iCountryCode.Copy( nwNames.iCountryCode );
       
   331                     __PHSLOGSTRING1("[PHS]   CPsetNetwork::RunL: CountryCode: %S", &iTempNetInfo.iId.iCountryCode);
       
   332 
       
   333                     iTempNetInfo.iId.iNetworkCode.Copy( nwNames.iNetworkId );
       
   334                     __PHSLOGSTRING1("[PHS]   CPsetNetwork::RunL: NetworkCode: %S", &iTempNetInfo.iId.iNetworkCode);
       
   335                     
       
   336                     iTempNetInfo.iStatus = (MPsetNetworkSelect::TNetworkStatus)nwNames.iStatus;
       
   337                     __PHSLOGSTRING1("[PHS]   CPsetNetwork::RunL: Status: %d", &iTempNetInfo.iStatus);
       
   338 
       
   339                     iTempNetInfo.iLongName.Copy( nwNames.iLongName );
       
   340                     __PHSLOGSTRING1("[PHS]   CPsetNetwork::RunL: LongName: %S", &iTempNetInfo.iLongName);
       
   341 
       
   342                     iTempNetInfo.iShortName.Copy( nwNames.iShortName );
       
   343                     __PHSLOGSTRING1("[PHS]   CPsetNetwork::RunL: ShortName: %S", &iTempNetInfo.iShortName);
       
   344 
       
   345                     if ( nwNames.iAccess == RMobilePhone::ENetworkAccessUtran )
       
   346                         {
       
   347                         iTempNetInfo.iAccess = ENetNetworkWCDMA;
       
   348                         }
       
   349                     else if ( nwNames.iAccess == RMobilePhone::ENetworkAccessGsmAndUtran )
       
   350                         {
       
   351                         iTempNetInfo.iAccess = ENetNetworkGSMandWCDMA;
       
   352                         }
       
   353                     else
       
   354                         {
       
   355                         iTempNetInfo.iAccess = ENetNetworkGSM;
       
   356                         }
       
   357                     array->AppendL( iTempNetInfo );
       
   358                     i++;       
       
   359                     }
       
   360                 CleanupStack::PopAndDestroy( results );
       
   361                 results = NULL;
       
   362                 __PHSLOGSTRING1("[PHS]   CPsetNetwork::RunL: Count: %d", array->Count());
       
   363                 iObserver->HandleNetworkInfoReceivedL( array, KErrNone );
       
   364                 CleanupStack::PopAndDestroy( array );
       
   365                 array = NULL;
       
   366                 break;        
       
   367                 }
       
   368             case MPsetNetworkInfoObserver::EServiceRequestSetNetwork:
       
   369                 {
       
   370                 __PHSLOGSTRING("[PHS]   CPsetNetwork::RunL: EServiceRequestSetNetwork");
       
   371                 GetRegistrationStatusL();
       
   372                 iObserver->HandleNetworkChangedL( iTempNetInfo,
       
   373                     iRegStatus, KErrNone );
       
   374                 break;
       
   375                 }
       
   376             default:
       
   377                 break;
       
   378             }
       
   379 
       
   380         //check if this is correct
       
   381         switch ( modeRequest )
       
   382             {
       
   383             case MPsetNetworkModeObserver::EServiceRequestSetSelectedNetworkMode:
       
   384                 __PHSLOGSTRING("[PHS]   CPsetNetwork::RunL: EServiceRequestSetSelectedNetworkMode");
       
   385                 iNetworkModeObserver->HandleNetworkSystemModeEventsL( 
       
   386                                                        modeRequest,
       
   387                                                        iNetworkModeCaps );
       
   388                 break;
       
   389             case MPsetNetworkModeObserver::EServiceRequestGetCurrentNetworkMode:
       
   390                 __PHSLOGSTRING("[PHS]   CPsetNetwork::RunL: EServiceRequestGetCurrentNetworkMode");
       
   391                 iNetworkModeObserver->HandleNetworkSystemModeEventsL( 
       
   392                                                        modeRequest,
       
   393                                                        iNetworkModeCaps );
       
   394                 break;            
       
   395             default:
       
   396                 break;
       
   397             }
       
   398         }
       
   399     __PHSLOGSTRING("[PHS] <--CPsetNetwork::RunL");
       
   400     }
       
   401 
       
   402 // ---------------------------------------------------------------------------
       
   403 // 
       
   404 // Cancels pending request
       
   405 // 
       
   406 // ---------------------------------------------------------------------------
       
   407 //
       
   408 void CPsetNetwork::DoCancel()
       
   409     {
       
   410     __PHSLOGSTRING("[PHS]--> CPsetNetwork::DoCancel");
       
   411     switch ( iServiceRequest )
       
   412         {
       
   413         case MPsetNetworkInfoObserver::EServiceRequestGetNetworkInfo:
       
   414             iNetworkRetrieve->Cancel();
       
   415             delete iNetworkRetrieve;
       
   416             iNetworkRetrieve = NULL;
       
   417             break;
       
   418         case MPsetNetworkInfoObserver::EServiceRequestSetNetwork:
       
   419         case MPsetNetworkInfoObserver::EServiceRequestSetNetworkAutomatic:
       
   420             iPhone.CancelAsyncRequest( EMobilePhoneSelectNetwork );
       
   421             break;
       
   422         default:            
       
   423             break;
       
   424         }
       
   425 
       
   426     switch ( iModeRequest )
       
   427         {
       
   428         case MPsetNetworkModeObserver::EServiceRequestSetSelectedNetworkMode:
       
   429             iCustomPhone.CancelAsyncRequest( ECustomSetSystemNetworkModeIPC );
       
   430             break;
       
   431         case MPsetNetworkModeObserver::EServiceRequestGetCurrentNetworkMode:
       
   432             __PHSLOGSTRING("[PHS]--> CPsetNetwork::EServiceRequestGetCurrentNetworkMode");
       
   433             iCustomPhone.CancelAsyncRequest( 
       
   434                 ECustomGetCurrentSystemNetworkModesIPC );
       
   435             __PHSLOGSTRING("[PHS]--> CPsetNetwork::EServiceRequestGetCurrentNetworkMode 2");
       
   436             break;
       
   437         default:
       
   438             break;
       
   439         }
       
   440 
       
   441     ClearParams();
       
   442     __PHSLOGSTRING("[PHS] <--CPsetNetwork::DoCancel");
       
   443     }
       
   444 
       
   445 // ---------------------------------------------------------------------------
       
   446 // 
       
   447 // Cancels current request
       
   448 // 
       
   449 // ---------------------------------------------------------------------------
       
   450 //
       
   451 EXPORT_C void CPsetNetwork::CancelProcess()
       
   452     {
       
   453     if ( !IsActive() )
       
   454         {
       
   455         //if not active, might mean that network list is shown, 
       
   456         // but call is incoming do not leave or raise error.
       
   457         }
       
   458     
       
   459     Cancel();
       
   460     }
       
   461 
       
   462 // ---------------------------------------------------------------------------
       
   463 // 
       
   464 // Sets observer (Observer starts to listen again if reset).
       
   465 // 
       
   466 // ---------------------------------------------------------------------------
       
   467 //
       
   468 EXPORT_C void CPsetNetwork::SetNetSAObserver( MPsetNetworkInfoObserver& aObserver )
       
   469     {
       
   470     __ASSERT_ALWAYS( iSAObserver, Panic( KPSNameOfClass, ENetNoObserver ) );
       
   471     iSAObserver->SetNetObserver( aObserver );
       
   472     }
       
   473 
       
   474 // ---------------------------------------------------------------------------
       
   475 // 
       
   476 // Adds this to scheduler
       
   477 // 
       
   478 // ---------------------------------------------------------------------------
       
   479 //
       
   480 void CPsetNetwork::ConstructL( MPsetNetworkInfoObserver& aObserver )
       
   481     {
       
   482     iObserver = &aObserver;
       
   483     iActiveObserver = ENetSelectObserver;
       
   484     /*****************************************************
       
   485     *    Series 60 Customer / ETel
       
   486     *    Series 60  ETel API
       
   487     *****************************************************/
       
   488     iRegStatus = RMobilePhone::ERegistrationUnknown;
       
   489     User::LeaveIfError( iCustomPhone.Open( iPhone ) );
       
   490     
       
   491     iSAObserver = CPsetSAObserver::NewL();
       
   492     CActiveScheduler::Add( this );
       
   493     }
       
   494 
       
   495 // ---------------------------------------------------------------------------
       
   496 // 
       
   497 // Adds this to scheduler
       
   498 // 
       
   499 // ---------------------------------------------------------------------------
       
   500 //
       
   501 void CPsetNetwork::ConstructL( MPsetNetworkModeObserver& aModeObserver )
       
   502     {
       
   503     iNetworkModeObserver = &aModeObserver;
       
   504     iActiveObserver = ENetModeObserver;
       
   505     /*****************************************************
       
   506     *    Series 60 Customer / ETel
       
   507     *    Series 60  ETel API
       
   508     *****************************************************/
       
   509     User::LeaveIfError( iCustomPhone.Open( iPhone ) );
       
   510     
       
   511     CActiveScheduler::Add( this );
       
   512     }
       
   513 
       
   514 // ---------------------------------------------------------------------------
       
   515 // 
       
   516 // C++ constructor.
       
   517 // 
       
   518 // ---------------------------------------------------------------------------
       
   519 //
       
   520 CPsetNetwork::CPsetNetwork
       
   521                 ( RMobilePhone& aPhone ) : CActive( EPriorityStandard ),
       
   522                                            iPhone ( aPhone )
       
   523     {
       
   524     }
       
   525 
       
   526 // ---------------------------------------------------------------------------
       
   527 // 
       
   528 // Gets registration status.
       
   529 // 
       
   530 // ---------------------------------------------------------------------------
       
   531 //
       
   532 void CPsetNetwork::GetRegistrationStatusL()
       
   533     {
       
   534     TRequestStatus status;
       
   535     iPhone.GetNetworkRegistrationStatus( status, iRegStatus );
       
   536     __PHSLOGSTRING1("[PHS]   CPsetNetwork::GetRegistrationStatusL: iRegStatus: %d", iRegStatus);
       
   537     User::WaitForRequest( status );
       
   538     User::LeaveIfError(status.Int());
       
   539     }
       
   540 
       
   541 // ---------------------------------------------------------------------------
       
   542 // 
       
   543 // Requests SAObserver to check if call is active.
       
   544 // 
       
   545 // ---------------------------------------------------------------------------
       
   546 //
       
   547 EXPORT_C TInt CPsetNetwork::IsCallActive()
       
   548     {
       
   549     return iSAObserver->IsCallActive();
       
   550     }
       
   551 
       
   552 // ---------------------------------------------------------------------------
       
   553 // 
       
   554 // Requests SAObserver to check if gprs connection is active.
       
   555 // 
       
   556 // ---------------------------------------------------------------------------
       
   557 //
       
   558 EXPORT_C TInt CPsetNetwork::IsGPRSConnected()
       
   559     {
       
   560     return iSAObserver->IsGPRSConnected();
       
   561     }
       
   562 
       
   563 // ---------------------------------------------------------------------------
       
   564 // 
       
   565 // Requests ETEL to Reset back to the previously used network.
       
   566 // 
       
   567 // ---------------------------------------------------------------------------
       
   568 //
       
   569 EXPORT_C TInt CPsetNetwork::ResetNetworkSearch()
       
   570     {
       
   571     __PHSLOGSTRING("[PHS]--> CPsetNetwork::ResetNetworkSearch");
       
   572     RMmCustomAPI customApi;
       
   573     TInt error = customApi.Open( iPhone );
       
   574     if  (error == KErrNone)
       
   575         {
       
   576         customApi.ResetNetServer();
       
   577         }
       
   578     customApi.Close();
       
   579 
       
   580     __PHSLOGSTRING("[PHS] <--CPsetNetwork::ResetNetworkSearch");
       
   581     //for compatibility reasons returns a value
       
   582     return error;
       
   583     }
       
   584 
       
   585 // ---------------------------------------------------------------------------
       
   586 // 
       
   587 // Hides requesting note (either type). Cannot leave, since only deletes notes.
       
   588 // 
       
   589 // ---------------------------------------------------------------------------
       
   590 //
       
   591 void CPsetNetwork::HideRequestNoteL()
       
   592     {
       
   593     // Hide requesting note, when interrupting a note, does not leave.
       
   594     if ( iServiceRequest == 
       
   595         MPsetNetworkInfoObserver::EServiceRequestGetNetworkInfo )
       
   596         {
       
   597         iObserver->HandleSearchingNetworksL( // Does not leave
       
   598             MPsetNetworkInfoObserver::EServiceRequestNone ); 
       
   599         }
       
   600     else //may cause unnecessary call to hide non-existing note
       
   601         {
       
   602         iObserver->HandleRequestingSelectedNetworkL( EFalse ); // Does not leave
       
   603         }
       
   604     }
       
   605 
       
   606 // ---------------------------------------------------------------------------
       
   607 // 
       
   608 // Push object into cleanupstack to catch leaving.
       
   609 // 
       
   610 // ---------------------------------------------------------------------------
       
   611 //
       
   612 void CPsetNetwork::CleanupLeavePushL()
       
   613     {
       
   614     CleanupStack::PushL( TCleanupItem( DoHandleLeave, this ) );
       
   615     }
       
   616 
       
   617 // ---------------------------------------------------------------------------
       
   618 // 
       
   619 // Object has caused a leave.
       
   620 // 
       
   621 // ---------------------------------------------------------------------------
       
   622 //
       
   623 void CPsetNetwork::DoHandleLeave( TAny* aAny )
       
   624     {
       
   625     REINTERPRET_CAST( CPsetNetwork*, aAny )->HandleLeave();
       
   626     }
       
   627 
       
   628 // ---------------------------------------------------------------------------
       
   629 // 
       
   630 // Things to do when leave occurs.
       
   631 // 
       
   632 // ---------------------------------------------------------------------------
       
   633 //
       
   634 void CPsetNetwork::HandleLeave()
       
   635     {
       
   636     CancelProcess();
       
   637     }
       
   638 
       
   639 // ---------------------------------------------------------------------------
       
   640 // 
       
   641 // Clears member variables
       
   642 // 
       
   643 // ---------------------------------------------------------------------------
       
   644 //
       
   645 void CPsetNetwork::ClearParams()
       
   646     {
       
   647     iNwInfo.iCountry = KNullDesC;
       
   648     iNwInfo.iNetwork = KNullDesC;
       
   649     iServiceRequest = MPsetNetworkInfoObserver::EServiceRequestNone;
       
   650     iModeRequest = MPsetNetworkModeObserver::EServiceRequestNone;
       
   651     }
       
   652 
       
   653 
       
   654 // ---------------------------------------------------------------------------
       
   655 // 
       
   656 // Sets the network mode observer for communication.
       
   657 // This method is called from CGSSettListNetView class.
       
   658 // 
       
   659 // ---------------------------------------------------------------------------
       
   660 //
       
   661 EXPORT_C void CPsetNetwork::SetNetworkModeObserver( MPsetNetworkModeObserver& 
       
   662                                                     aObserver )
       
   663     {
       
   664     iNetworkModeObserver = &aObserver;
       
   665     }
       
   666 
       
   667 
       
   668 // ---------------------------------------------------------------------------
       
   669 // 
       
   670 // Sets the currently selected network access mode (GSM/UMTS/DualMode).
       
   671 // 
       
   672 // ---------------------------------------------------------------------------
       
   673 //
       
   674 EXPORT_C void CPsetNetwork::SetNetworkModeSelectionL( TUint32& aNetworkMode )
       
   675     {
       
   676     __PHSLOGSTRING("[PHS]--> CPsetNetwork::SetNetworkModeSelectionL");
       
   677 
       
   678     if ( IsActive() )
       
   679         {
       
   680         User::Leave( KErrInUse );
       
   681         }
       
   682 
       
   683     iModeRequest = 
       
   684         MPsetNetworkModeObserver::EServiceRequestSetSelectedNetworkMode;
       
   685     iCustomPhone.SetSystemNetworkMode( iStatus, 
       
   686                  static_cast<RMmCustomAPI::TNetworkModeCaps>( aNetworkMode ) );
       
   687     SetActive();
       
   688 
       
   689     __PHSLOGSTRING("[PHS] <--CPsetNetwork::SetNetworkModeSelectionL");
       
   690     }
       
   691 
       
   692 
       
   693 // ---------------------------------------------------------------------------
       
   694 // 
       
   695 // Gets the currently selected network access mode (GSM/UMTS/DualMode).
       
   696 // 
       
   697 // ---------------------------------------------------------------------------
       
   698 //
       
   699 EXPORT_C void CPsetNetwork::GetCurrentNetworkModeSelectionL()
       
   700     {
       
   701     __PHSLOGSTRING("[PHS]--> CPsetNetwork::GetCurrentNetworkModeSelectionL");
       
   702 
       
   703     if ( IsActive() )
       
   704         {
       
   705         User::Leave( KErrInUse );
       
   706         }
       
   707 
       
   708     iModeRequest = 
       
   709         MPsetNetworkModeObserver::EServiceRequestGetCurrentNetworkMode;
       
   710     iCustomPhone.GetCurrentSystemNetworkModes( iStatus, iNetworkModeCaps );
       
   711     SetActive();
       
   712 
       
   713     __PHSLOGSTRING("[PHS] <--CPsetNetwork::GetCurrentNetworkModeSelectionL");
       
   714     }
       
   715 
       
   716 
       
   717 // End of file