1 /*

     2 * Copyright (c) 2006-2008 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:  Call submenu in General Settings.

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 #include "GSNetworkPlugin.h"         //for CGSCallPlugin

    21 #include "GSNetworkPluginContainer.h"    //for CGSCallPluginContainer

    22 #include "GsLogger.h"

    23 #include "GSNetworkPlugin.h"             //for pluginUID

    24 

    25 #include <coeaui.h>

    26 #include <hlplch.h>                     // For HlpLauncher

    27 

    28 //AVKON headers

    29 #include <aknnotewrappers.h>            //for Note Wrappers

    30 #include <aknPopup.h>                   //for Popup menus

    31 #include <aknradiobuttonsettingpage.h>  //for Radio Button Setting Pages

    32 #include <aknViewAppUi.h>               //for viewappui

    33 #include <AknWaitDialog.h>              //for CAknWaitDialog

    34 #include <AknIconArray.h>               //for AknIconArray

    35 #include <StringLoader.h>               //for StringLoader

    36 #include <apparc.h>

    37 

    38 #include <gscommon.hrh>

    39 

    40 //Phonesettings and TSY headers

    41 #include <PsetContainer.h>              //for CPsetContainer

    42 #include <PsetNetwork.h>                //for CPsetNetwork

    43 #include <PsetSAObserver.h>             //for CPsetSAObserver

    44 #include <gsmerror.h>                   //for GSM-specific error messages

    45 #include <exterror.h>

    46 #include <featmgr.h>

    47 #include <MSSSettingsRefreshObserver.h> //for SAT refresh

    48 #include <gslistbox.h>                  //for radiobutton class

    49 

    50 #include <e32property.h>

    51 #include <PSVariables.h>

    52 

    53 #include <GsNetworkPluginRsc.rsg>           //for resource IDs

    54 #include <gsfwviewuids.h>

    55 #include <gslistbox.h>                  //for CGSListBoxItemTextArray

    56 

    57 #include <e32property.h>

    58 #include <PSVariables.h>

    59 #include <gsprivatepluginproviderids.h>

    60 #include <gsnetworkplugin.mbg>

    61 #include <BTSapInternalPSKeys.h>

    62 #include <CoreApplicationUIsSDKCRKeys.h> // KCRUidCoreApplicationUIs, TCoreAppUIsNetworkConnectionAllowed

    63 #include <activeidle2domainpskeys.h>

    64 

    65 #include <CNWSession.h>

    66 #include <NetworkHandlingProxy.h>

    67 #include <gsparentplugin.h>

    68 #include "GSNetworkDebugHelper.h"

    69 

    70 #ifdef FF_POWER_SAVE

    71     #include "GSNetworkPluginAO.h"

    72 #endif // FF_POWER_SAVE

    73 

    74 // LOCAL CONSTANTS

    75 _LIT( KGSNetWCDMAIcon, "0\t" );

    76 _LIT( KGSNetGSMIcon, "1\t" );

    77 _LIT( KEmptyStr, "" );

    78 

    79 // Warning disabled as this constant is used inside __ASSERT_DEBUG

    80 #pragma diag_suppress 177

    81 _LIT( KGSNetworkPluginAssertName, "CGSNetworkPlugin" );

    82 

    83 

    84 // Middle Softkey control ID.

    85 const TInt KGSMSKControlID = 3;

    86 

    87 const TInt KGSNetIconAdditionalChars = 5;

    88 

    89 

    90 // ========================= MEMBER FUNCTIONS ================================

    91 // ---------------------------------------------------------------------------

    92 //

    93 // Constructor.

    94 //

    95 // ---------------------------------------------------------------------------

    96 CGSNetworkPlugin::CGSNetworkPlugin()

    97     :iMskCommandFlag( ETrue ) , iPsmActive( NULL )

    98     {

    99     }

   100 

   101 // ---------------------------------------------------------------------------

   102 //

   103 // Symbian OS two-phased constructor (second phase)

   104 //

   105 // ---------------------------------------------------------------------------

   106 void CGSNetworkPlugin::ConstructL()

   107     {

   108     __GSLOGSTRING("[CGSNetworkPlugin]--> CGSNetworkPlugin::ConstructL");

   109     FeatureManager::InitializeLibL();

   110     OpenLocalizedResourceFileL( KGSNetworkPluginResourceFileName,

   111                                 iResourceLoader );

   112 

   113     //PS listener initialization

   114     iBtSapListener = CGSPubSubsListener::NewL(

   115                      KPSUidBluetoothSapConnectionState,

   116                      KBTSapConnectionState, this );

   117 

   118     BaseConstructL( R_GS_NET_VIEW );

   119 

   120     iSettingsContainer = CPsetContainer::NewL();

   121     iPSRefreshHandler = iSettingsContainer->CreateRefreshHandlerL();

   122     iPSRefreshHandler->NotifyFileChangeL(

   123             *this,

   124             KCspEf,

   125             EFileChangeNotification );

   126     iPhoneSettingsEngine = iSettingsContainer->CreateNetworkObjectL( *this );

   127     iApprovedNetwork = EFalse;

   128     CheckAndCreateDlgL( EFalse );

   129     iSearchForNetworksActive = EFalse;

   130 

   131     iNetworkText = HBufC::NewL( KNWShortNameLength );

   132     UpdateNetworkTextL();

   133     

   134 #ifdef FF_POWER_SAVE    

   135     iPsmActive = CGSNetworkPluginAO::NewL();

   136     iPsmActive->SetView( this );

   137 #endif // FF_POWER_SAVE   

   138 

   139     __GSLOGSTRING("[CGSNetworkPlugin] <--CGSNetworkPlugin::ConstructL");

   140     }

   141 

   142 // ---------------------------------------------------------------------------

   143 //

   144 // Symbian OS two-phased constructor (first phase)

   145 //

   146 // ---------------------------------------------------------------------------

   147 CGSNetworkPlugin* CGSNetworkPlugin::NewLC()

   148     {

   149     CGSNetworkPlugin* self = new ( ELeave ) CGSNetworkPlugin;

   150     CleanupStack::PushL( self );

   151     self->ConstructL();

   152     return self;

   153     }

   154 

   155 // ---------------------------------------------------------------------------

   156 // CGSNetworkPlugin::NewL()

   157 // Static constructor

   158 //

   159 // ---------------------------------------------------------------------------

   160 //

   161 CGSNetworkPlugin* CGSNetworkPlugin::NewL( TAny* /*aInitParams*/ )

   162     {

   163     CGSNetworkPlugin* self = new ( ELeave ) CGSNetworkPlugin();

   164     CleanupStack::PushL( self );

   165     self->ConstructL();

   166     CleanupStack::Pop( self );

   167     return self;

   168     }

   169 

   170 // ---------------------------------------------------------------------------

   171 //

   172 // Destructor

   173 //

   174 // ---------------------------------------------------------------------------

   175 CGSNetworkPlugin::~CGSNetworkPlugin()

   176     {

   177     __GSLOGSTRING("[CGSNetworkPlugin] ~CGSNetworkPlugin()|->");

   178     FeatureManager::UnInitializeLib();

   179 

   180     if( iNWSession )

   181         {

   182         delete iNWSession;

   183         iNWSession = NULL;

   184         }

   185     if ( iBtSapListener )

   186         {

   187         delete iBtSapListener;

   188         iBtSapListener = NULL;

   189         }

   190 

   191     if ( iPhoneSettingsEngine )

   192         {

   193         if( iSearchForNetworksActive )

   194             {

   195             //Reset back to previously used network

   196             iPhoneSettingsEngine->ResetNetworkSearch();

   197             }

   198         delete iPhoneSettingsEngine;

   199         iPhoneSettingsEngine = NULL;

   200         }

   201 

   202     if ( iNetworkArray )

   203         {

   204         iNetworkArray->Reset();

   205         delete iNetworkArray;

   206         iNetworkArray = NULL;

   207         }

   208 

   209     if ( iDlg )

   210         {

   211         delete iDlg;

   212         iDlg = NULL;

   213         }

   214     if ( iNetworkPopupList )

   215         {

   216         iNetworkPopupList->CancelPopup();

   217         }

   218 

   219     CloseDialog();

   220     

   221     //Cancel any outstanding SAT notifications

   222     if ( iPSRefreshHandler )

   223         {

   224         iPSRefreshHandler->CancelNotify();

   225         delete iPSRefreshHandler;

   226         iPSRefreshHandler = NULL;

   227         }

   228 

   229     if( iSettingsContainer )

   230         {

   231         delete iSettingsContainer;

   232         iSettingsContainer = NULL;

   233         }

   234 

   235     delete iNetworkText;

   236     iNetworkText = NULL;

   237     

   238 #ifdef FF_POWER_SAVE

   239     delete iPsmActive;

   240     iPsmActive = NULL;

   241 #endif // FF_POWER_SAVE

   242 

   243     __GSLOGSTRING("[CGSNetworkPlugin] ~CGSNetworkPlugin()-|");

   244     }

   245 

   246 // ---------------------------------------------------------------------------

   247 //

   248 // Returns Id of the Network submenu

   249 //

   250 // ---------------------------------------------------------------------------

   251 TUid CGSNetworkPlugin::Id() const

   252     {

   253     return KGSNetworkPluginUid;

   254     }

   255 

   256 // ----------------------------------------------------------------------------

   257 // CGSNetworkPlugin::Visible

   258 //

   259 // Provides the visibility status of self to framework.

   260 // ----------------------------------------------------------------------------

   261 //

   262 TBool CGSNetworkPlugin::Visible() const

   263     {

   264     TBool result( EFalse );

   265     TInt value = 0;

   266     iBtSapListener->Get( value );

   267     if ( value == EBTSapNotConnected || value == EBTSapConnecting )

   268         {

   269         result = ETrue;

   270         }

   271     else

   272         {

   273         result = EFalse;

   274         }

   275     return result;

   276     }

   277 

   278 // ---------------------------------------------------------------------------

   279 //

   280 // Handles network info

   281 //

   282 // ---------------------------------------------------------------------------

   283 void CGSNetworkPlugin::HandleNetworkInfoReceivedL(

   284         const CNetworkInfoArray* aInfoArray, const TInt /* aResult */ )

   285     {

   286     __GSLOGSTRING("[GS]--> CGSNetworkPlugin::HandleNetworkInfoReceivedL");

   287     const TInt itemsCount = aInfoArray->Count();

   288 

   289     //first delete old ones

   290     iNetworkArray->Delete( 0, iNetworkArray->Count() );

   291 

   292     //then insert found networks

   293     for ( TInt i = 0; i < itemsCount; i++ )

   294         {

   295         MPsetNetworkSelect::TNetworkInfo info = aInfoArray->At( i );

   296         iNetworkArray->InsertL( i, info );

   297         }

   298     NetworkListL(); //after search complete, show results

   299     __GSLOGSTRING("[GS] <--CGSNetworkPlugin::HandleNetworkInfoReceivedL");

   300     }

   301 

   302 // ---------------------------------------------------------------------------

   303 //

   304 // Creates list of Network providers

   305 //

   306 // ---------------------------------------------------------------------------

   307 void CGSNetworkPlugin::NetworkListL()

   308     {

   309     __GSLOGSTRING("[GS]--> CGSNetworkPlugin::NetworkListL");

   310 

   311     //check if the graphical list is needed... set in local variation

   312     TBool showGraphicalList =

   313         Container()->NetPluginModel()->GraphicalNetworkListSupportedL();

   314     __GSLOGSTRING1("[GS]    NetworkListL: showGraphicalList: %d", showGraphicalList);

   315 

   316     //if no net items were found, do not show list

   317     if ( iNetworkArray->Count() > 0 )

   318         {

   319         while ( !iApprovedNetwork )

   320             {

   321             AknPopupListEmpty<CEikFormattedCellListBox>* list;

   322             if ( showGraphicalList &&

   323                  FeatureManager::FeatureSupported( KFeatureIdProtocolWcdma ) )

   324                 {

   325                 list = new ( ELeave ) CAknSingleGraphicPopupMenuStyleListBox;

   326                 }

   327             else

   328                 {

   329                 list = new ( ELeave ) CAknSinglePopupMenuStyleListBox;

   330                 }

   331 

   332             CleanupStack::PushL( list );

   333             if ( iNetworkPopupList )

   334                 {

   335                 iNetworkPopupList->CancelPopup();

   336                 iNetworkPopupList = NULL;

   337                 }

   338             iNetworkPopupList =

   339                 CAknPopupList::NewL( list, R_AVKON_SOFTKEYS_OK_CANCEL );

   340 

   341             list->ConstructL( iNetworkPopupList,

   342                               CEikListBox::ELeftDownInViewRect );

   343             list->CreateScrollBarFrameL( ETrue );

   344             list->ScrollBarFrame()->SetScrollBarVisibilityL(

   345                 CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto );

   346 

   347             //Fill in the list texts

   348             CDesCArrayFlat* items =

   349                 new ( ELeave ) CDesCArrayFlat( KGSNetPopupMenuItems );

   350             CleanupStack::PushL( items );

   351             const TInt itemsCount = iNetworkArray->Count();

   352             __GSLOGSTRING1("[GS]    NetworkListL: itemsCount: %d", itemsCount);

   353 

   354             for ( TInt loop = 0; loop < itemsCount; loop++ )

   355                 {

   356                 HBufC* insertString =

   357                     HBufC::NewLC(

   358                         KGSNwLongNameLength + KGSNetIconAdditionalChars );

   359                 MPsetNetworkSelect::TNetworkInfo info =

   360                     iNetworkArray->At( loop );

   361 

   362                 if ( info.iLongName.Length() <= 0 ||

   363                      info.iLongName.Length() > KGSNwLongNameLength )

   364                     {

   365                     //no names received, use IDs

   366                     if ( info.iShortName.Length() <= 0 ||

   367                         info.iShortName.Length() > KGSNwShortNameLength )

   368                         {

   369                         TNetworkID ids;

   370                         TNetworkID networkCode;

   371                         ids = info.iId.iCountryCode;

   372                         ids.Append( KGSEmptySpace );

   373                         networkCode = info.iId.iNetworkCode;

   374                         ids.Append( networkCode );

   375                         insertString->Des().Append( ids );

   376                         __GSLOGSTRING1("[GS]    NetworkListL: Network ID: %S", insertString);

   377                         }

   378                     //short name received

   379                     else

   380                         {

   381                         insertString->Des().Append( info.iShortName );

   382                         __GSLOGSTRING1("[GS]    NetworkListL: Network Shortname: %S", insertString);

   383                         }

   384                     }

   385                 //long name received

   386                 else

   387                     {

   388                     insertString->Des().Append( info.iLongName );

   389                     __GSLOGSTRING1("[GS]    NetworkListL: Network Longname: %S", insertString);

   390                     }

   391 

   392                 //set icon for network

   393                 if ( showGraphicalList )

   394                     {

   395                     if ( FeatureManager::FeatureSupported(

   396                                                   KFeatureIdProtocolWcdma ) )

   397                         {

   398                         if ( info.iAccess !=

   399                              MPsetNetworkSelect::ENetNetworkGSM )

   400                             {

   401                             insertString->Des().Insert( 0, KGSNetWCDMAIcon );

   402                             }

   403                         else

   404                             {

   405                             insertString->Des().Insert( 0, KGSNetGSMIcon );

   406                             }

   407                         }

   408                     }

   409                 items->AppendL( *insertString );

   410                 CleanupStack::PopAndDestroy();

   411                 }

   412 

   413             // For Testing purpuses ONLY

   414             for ( TInt k=0; k<items->Count(); k++ )

   415                 {

   416                 TPtrC itemText( (*items)[k] );

   417                 __GSLOGSTRING2("[GS]    NetworkListL: POS: %d, VALUE: %S", k, &itemText);

   418                 }

   419 

   420             CTextListBoxModel* model = list->Model();

   421             model->SetItemTextArray( items );

   422             model->SetOwnershipType( ELbmOwnsItemArray );

   423             CleanupStack::Pop( items ); //listbox model now owns this

   424 

   425             //Set title for list

   426             SetTitleToPopupL( *iNetworkPopupList, R_NETSL_FOUNDOPERATORS );

   427 

   428             // Setup graphic items list for dual mode nw selection listbox

   429             // based on the local variation

   430             if ( showGraphicalList )

   431                 {

   432                 CAknIconArray* iconList = new (ELeave) CAknIconArray( 10 );

   433                 CleanupStack::PushL( iconList );

   434                 iconList->ConstructFromResourceL( R_NET_DUALMODE_ICONS );

   435                 list->ItemDrawer()->ColumnData()->SetIconArray( iconList );

   436                 CleanupStack::Pop( iconList ); //listbox model now owns this

   437                 }

   438 

   439             TInt res = 0;

   440             if( items->Count() )

   441                 {

   442                 res = iNetworkPopupList->ExecuteLD();

   443                 }

   444             iNetworkPopupList = NULL;

   445 

   446             iApprovedNetwork = ETrue; //not perhaps, but user might want to quit

   447             TInt selection = list->CurrentItemIndex();

   448             __GSLOGSTRING1("[GS]    NetworkListL: selection: %d", selection);

   449 

   450             CleanupStack::PopAndDestroy( list );

   451 

   452             if ( res )

   453                 {

   454                 MPsetNetworkSelect::TNetworkInfo info =

   455                     iNetworkArray->At( selection );

   456                 info.iMode = MPsetNetworkSelect::ENetSelectModeManual;

   457                 iPhoneSettingsEngine->SelectNetworkL( info );

   458                 }

   459             else // user selected "Cancel"

   460                 {

   461                 //After list has been used, clear it.

   462                 PurgeNetworkList();

   463                 if ( iPhoneSettingsEngine->IsCallActive() !=

   464                      CPsetSAObserver::EPSetCallActive )

   465                     {

   466                     ShowSettingPageL( EGSNetworkModeSelectionItemId );

   467                     }

   468                 }

   469             }

   470         }

   471     iApprovedNetwork = EFalse; //initialize before new search

   472     __GSLOGSTRING("[GS] <--CGSNetworkPlugin::NetworkListL");

   473     }

   474 

   475 // ---------------------------------------------------------------------------

   476 //

   477 // Handles requests to change network

   478 //

   479 // ---------------------------------------------------------------------------

   480 void CGSNetworkPlugin::HandleNetworkChangedL(

   481     const MPsetNetworkSelect::TNetworkInfo& /*aCurrentInfo*/,

   482     const MPsetNetworkSelect::TCurrentNetworkStatus /*aStatus*/,

   483     const TInt /*aResult*/ )

   484     {

   485     //DEPRECATED

   486     }

   487 

   488 // ---------------------------------------------------------------------------

   489 //

   490 // Handles requests to change network

   491 //

   492 // ---------------------------------------------------------------------------

   493 void CGSNetworkPlugin::HandleNetworkChangedL(

   494     const MPsetNetworkSelect::TNetworkInfo& aCurrentInfo,

   495     const RMobilePhone::TMobilePhoneRegistrationStatus& aStatus,

   496     const TInt /* aResult */ )

   497     {

   498     __GSLOGSTRING("[GS]--> CGSNetworkPlugin::HandleNetworkChangedL");

   499     switch ( aStatus )

   500         {

   501         case RMobilePhone::ERegisteredOnHomeNetwork:

   502             ShowNoteL( R_HOME_NETWORK_SELECTED, KGSConfirmationNote );

   503             PurgeNetworkList();

   504             break;

   505         case RMobilePhone::ERegisteredRoaming:

   506             {

   507             HBufC* stringholder;

   508             if ( aCurrentInfo.iLongName.Length() > 0 &&

   509                 aCurrentInfo.iLongName.Length() <=

   510                 MPsetNetworkSelect::ENetLongNameSize )

   511                 {

   512                 stringholder = StringLoader::LoadLC( R_NETSL_NETWORKSELECTED,

   513                                                      aCurrentInfo.iLongName );

   514                 }

   515             else if (aCurrentInfo.iShortName.Length() > 0 &&

   516                 aCurrentInfo.iShortName.Length() <=

   517                 MPsetNetworkSelect::ENetShortNameSize )

   518                 {

   519                 stringholder = StringLoader::LoadLC( R_NETSL_NETWORKSELECTED,

   520                                                      aCurrentInfo.iShortName );

   521                 }

   522             else //network returned only ids

   523                 {

   524                 // construct whole "id-string"

   525                 // e.g. for Finland Nokia's test network "244 7"

   526                 TNetworkID ids;

   527                 TNetworkID networkCode;

   528                 ids = aCurrentInfo.iId.iCountryCode;

   529                 __GSLOGSTRING1("[GS]    HandleNetworkChangedL: iCountryCode: %S", &aCurrentInfo.iId.iCountryCode);

   530 

   531                 ids.Append( KGSEmptySpace );

   532                 networkCode = aCurrentInfo.iId.iNetworkCode;

   533                 __GSLOGSTRING1("[GS]    HandleNetworkChangedL: iNetworkCode: %S", &aCurrentInfo.iId.iNetworkCode);

   534 

   535                 ids.Append( networkCode );

   536                 stringholder =

   537                     StringLoader::LoadLC( R_NETSL_NETWORKSELECTED, ids );

   538                 }

   539             CAknConfirmationNote* note = new ( ELeave ) CAknConfirmationNote( ETrue );

   540             note->ExecuteLD( *stringholder );

   541             CleanupStack::PopAndDestroy( stringholder );

   542             //After list has been used, clear it.

   543             PurgeNetworkList();

   544             break;

   545             }

   546         case RMobilePhone::ERegistrationUnknown:

   547         case RMobilePhone::ENotRegisteredNoService:

   548         case RMobilePhone::ENotRegisteredEmergencyOnly:

   549         case RMobilePhone::ENotRegisteredSearching:

   550         case RMobilePhone::ERegisteredBusy:

   551         case RMobilePhone::ERegistrationDenied:

   552         default:

   553             break;

   554         }

   555     PhoneIdle();

   556     __GSLOGSTRING("[GS] <--CGSNetworkPlugin::HandleNetworkChangedL");

   557     }

   558 

   559 

   560 // ---------------------------------------------------------------------------

   561 //

   562 // Handles user inputs in Options menu

   563 //

   564 // ---------------------------------------------------------------------------

   565 void CGSNetworkPlugin::HandleCommandL( TInt aCommand )

   566     {

   567     __GSLOGSTRING1("[CGSNetworkPlugin] HandleCommandL(%d)|->", aCommand );

   568     switch ( aCommand )

   569         {

   570         case EGSMSKCmdAppChange:

   571              HandleListBoxSelectionL();

   572              break;

   573         case EGSCmdAppChange:

   574             {

   575             const TInt currentFeatureId = Container()->CurrentFeatureId();

   576 

   577             if ( currentFeatureId == EGSMCNItemId )

   578                 {

   579                 ShowSettingPageL( EGSMCNItemId );

   580                 }

   581             else if ( currentFeatureId == EGSNetworkModeItemId )

   582                 {

   583                 CheckCallActiveL( EGSNetworkModeItemId );

   584                 }

   585             else

   586                 {

   587                 HandleListBoxEventL( NULL, EEventEnterKeyPressed );

   588                 }

   589             }

   590             break;

   591         case EAknSoftkeyBack:

   592             {

   593             if (!iPhoneSettingsEngine->IsActive())

   594                 {

   595                 iAppUi->ActivateLocalViewL( KGSConPluginUid /*KGSTelPluginUid*/ );                

   596                 }

   597             break;

   598             }

   599         case EAknCmdHelp:

   600             {

   601             if( FeatureManager::FeatureSupported( KFeatureIdHelp ) )

   602                 {

   603                 HlpLauncher::LaunchHelpApplicationL(

   604                     iEikonEnv->WsSession(), iAppUi->AppHelpContextL() );

   605                 }

   606             break;

   607             }

   608         default:

   609             iAppUi->HandleCommandL( aCommand );

   610             break;

   611         }

   612     __GSLOGSTRING("[CGSNetworkPlugin] HandleCommandL()-|");

   613     }

   614 

   615 

   616 // ---------------------------------------------------------------------------

   617 //

   618 // Handles user inputs in Options menu

   619 //

   620 // ---------------------------------------------------------------------------

   621 void CGSNetworkPlugin::ProcessCommandL( TInt aCommand )

   622     {

   623     // Network base class

   624     CAknView::ProcessCommandL( aCommand );

   625     }

   626 

   627 // ---------------------------------------------------------------------------

   628 //

   629 // While request to find networks is processed

   630 //

   631 // ---------------------------------------------------------------------------

   632 void CGSNetworkPlugin::HandleSearchingNetworksL(

   633                          MPsetNetworkInfoObserver::TServiceRequest aRequest )

   634     {

   635     __GSLOGSTRING("[GS]--> CGSNetworkPlugin::HandleSearchingNetworksL");

   636     if ( !iNetworkArray )

   637         {

   638         iNetworkArray = new ( ELeave )

   639             CNetworkInfoArray( KGSNetworkInfoArrayGranularity );

   640         }

   641 

   642     if ( aRequest != MPsetNetworkInfoObserver::EServiceRequestNone )

   643         {

   644         CheckAndCreateDlgL( EFalse );

   645         if ( aRequest ==

   646              MPsetNetworkInfoObserver::EServiceRequestSetNetworkAutomatic )

   647             {

   648             UpdateListBoxL( EGSNetworkModeSelectionItemId,

   649                             EGSAutomaticSelectMode );

   650             }

   651         else

   652             {

   653             UpdateListBoxL( EGSNetworkModeSelectionItemId,

   654                             EGSManualSelectMode );

   655             }

   656 

   657         iSearchForNetworksActive = ETrue;

   658         TInt res = iDlg->ExecuteLD( R_SEARCHING_NOTE );

   659 

   660         if ( res == EGSSoftkeyQuit )

   661             {

   662             iPhoneSettingsEngine->CancelProcess();

   663             

   664             ShowSettingPageL( EGSNetworkModeSelectionItemId );

   665             }

   666         else

   667             {

   668             if ( aRequest ==

   669                  MPsetNetworkInfoObserver::EServiceRequestSetNetworkAutomatic )

   670                 {

   671                 PhoneIdle();

   672                 iAppUi->HandleCommandL( EEikCmdExit );

   673                 }

   674             }

   675         }

   676     else

   677         {

   678         delete iDlg;

   679         iDlg = NULL;

   680         }

   681 

   682     __GSLOGSTRING("[GS] <--CGSNetworkPlugin::HandleSearchingNetworksL");

   683     }

   684 

   685 // ---------------------------------------------------------------------------

   686 //

   687 // While request to change network is processed, a note is shown

   688 //

   689 // ---------------------------------------------------------------------------

   690 void CGSNetworkPlugin::HandleRequestingSelectedNetworkL( TBool aOngoing )

   691     {

   692     __GSLOGSTRING("[GS]--> CGSNetworkPlugin::HandleRequestingSelectedNetworkL");

   693     if ( aOngoing )

   694         {

   695         CheckAndCreateDlgL( ETrue );

   696 

   697         if ( iDlg->ExecuteLD( R_REQUESTING_NOTE ) == EGSSoftkeyQuit )

   698             {

   699             iPhoneSettingsEngine->CancelProcess();

   700 

   701             CAknNoteDialog* dlg = new ( ELeave ) CAknNoteDialog(

   702                 CAknNoteDialog::EConfirmationTone,

   703                 CAknNoteDialog::EShortTimeout );

   704             dlg->ExecuteLD( R_REGISTRATION_INTERRUPTED );

   705             iApprovedNetwork = EFalse;

   706             }

   707         }

   708     else

   709         {

   710         delete iDlg;

   711         iDlg = NULL;

   712         }

   713 

   714     __GSLOGSTRING("[GS] <--CGSNetworkPlugin::HandleRequestingSelectedNetworkL");

   715     }

   716 

   717 

   718 // ---------------------------------------------------------------------------

   719 //

   720 // Activates the view

   721 //

   722 // ---------------------------------------------------------------------------

   723 void CGSNetworkPlugin::DoActivateL( const TVwsViewId&  aPrevViewId ,

   724                                        TUid  aCustomMessageId,

   725                                        const TDesC8&  aCustomMessage  )

   726     {

   727     __GSLOGSTRING( "[CGSNetworkPlugin] DoActivateL()|->" );

   728     CGSBaseView::DoActivateL( aPrevViewId, aCustomMessageId, aCustomMessage );

   729     Container()->SetMiddleSoftkeyObserver( this );

   730     SetMiddleSoftKeyLabelL( R_CALL_MSK_CHANGE, EGSMSKCmdAppChange );

   731     // This way we set which command is set for MSK

   732     iMskCommandFlag = ETrue;

   733     iContainer->iListBox->SetTopItemIndex( iTopItemIndex );

   734 

   735     if ( iCurrentItem >= 0 &&

   736          iCurrentItem < iContainer->iListBox->Model()->NumberOfItems() )

   737         {

   738         iContainer->iListBox->SetCurrentItemIndexAndDraw( iCurrentItem );

   739         }

   740     if ( aCustomMessageId == TUid::Uid( KGSCustomActivateNetView ) )

   741        {

   742        UpdateListBoxL( EGSNetworkModeSelectionItemId, EGSManualSelectMode );

   743        iSearchForNetworksActive = ETrue;

   744        iPhoneSettingsEngine->GetAvailableNetworksL();

   745        }

   746     CheckMiddleSoftkeyLabelL();

   747     __GSLOGSTRING( "[CGSNetworkPlugin] DoActivateL()-|" );

   748     }

   749 

   750 // ---------------------------------------------------------------------------

   751 //

   752 // Deactivates the view

   753 //

   754 // ---------------------------------------------------------------------------

   755 void CGSNetworkPlugin::DoDeactivate()

   756     {

   757     __GSLOGSTRING("[CGSNetworkPlugin]--> DoDeactivate");

   758     if ( Container() )

   759         {

   760         if ( Container()->iListBox && iContainer->iListBox->View() )

   761             {

   762             iTopItemIndex = iContainer->iListBox->TopItemIndex();

   763             iCurrentItem = iContainer->iListBox->CurrentItemIndex();

   764             }

   765         iAppUi->RemoveFromViewStack( *this, Container() );

   766         delete iContainer;

   767         iContainer = NULL;

   768         }

   769     __GSLOGSTRING("[CGSNetworkPlugin] <--DoDeactivate");

   770     }

   771 

   772 // ---------------------------------------------------------------------------

   773 //

   774 // Shows setting page - for ON/OFF setting items

   775 //

   776 // ---------------------------------------------------------------------------

   777 void CGSNetworkPlugin::ShowSettingPageL( TGSNetworkItemIds aPage )

   778     {

   779     __GSLOGSTRING( "[CGSNetworkPlugin::ShowSettingPageL]" );

   780     TInt resourceId = 0;

   781     TInt currentItem = KGSSettingOff;

   782     HBufC* settingPageTitle = NULL;

   783 

   784     switch( aPage )

   785         {

   786         case EGSNetworkModeSelectionItemId:

   787             resourceId = R_NETSL_NETSELECTMODE_LBX;

   788             settingPageTitle = StringLoader::LoadLC( R_NETSL_NETSELECTMODE );

   789             currentItem = Container()->GetSelectionMode();

   790             break;

   791         case EGSMCNItemId:

   792             resourceId = R_MCN_CELL_INFO_DISP_MODE_LBX;

   793             settingPageTitle = StringLoader::LoadLC( R_MCN_CELL_INFO_DISP_MODE );

   794             Container()->GetMcnValue( iMCN );

   795             //for MCN, values need to be switched since Off = 0 in shared data, 1 on screen

   796             SwitchOnOffValue( iMCN );

   797             currentItem = iMCN;

   798             break;

   799         case EGSNetworkModeItemId:

   800             resourceId = R_NET_NETWORK_MODE_LBX;

   801             settingPageTitle = StringLoader::LoadLC( R_NET_NETWORK_MODE );

   802             currentItem = Container()->GetCurrentNetworkModeSelectionL();

   803             break;

   804         default:

   805             break;

   806         }

   807 

   808     

   809 

   810     //Checking if the phone is in offline mode

   811     const TBool iOfflineMode = IsPhoneOfflineL();

   812 

   813     // If it is in offline mode, then we dont launch the NW mode setting page at all

   814     if (  iOfflineMode /*&& aPage == EGSNetworkModeItemId*/ )

   815         {

   816         HBufC* string = StringLoader::LoadLC( R_OFFLINE_MODE );

   817         CAknErrorNote* note = new ( ELeave ) CAknErrorNote ( ETrue );

   818         note->ExecuteLD( *string );

   819         CleanupStack::PopAndDestroy( string );

   820         }

   821     else // if not offline mode we show the setting page

   822         {

   823         

   824         CGSRadioButtonSettingPageItemTextArray* itemArray =

   825                 CGSRadioButtonSettingPageItemTextArray::NewL( resourceId, *iCoeEnv, NULL );

   826 

   827         // network mode requires special handling as items in the settings page

   828         // are variated. The method below checks which items to display & hide.

   829         if ( aPage == EGSNetworkModeItemId )

   830             {

   831             Container()->CheckAndAlterContentsL( *itemArray );

   832             }

   833 

   834         CleanupStack::PushL( itemArray );

   835 

   836         TInt currentIndex = itemArray->IndexForFeatureIdL( currentItem );

   837 

   838         // no editor resource given

   839         iSettingDlg = new ( ELeave ) CAknRadioButtonSettingPage(

   840                 settingPageTitle, EAknSettingPageNoOrdinalDisplayed, 0, 0,

   841                 R_SETTING_PAGE, currentIndex, itemArray );

   842         itemArray->SetRadioButtonSettingPage( *iSettingDlg );

   843 

   844         const TInt prevSelection = currentIndex;

   845         if ( settingPageTitle )

   846         	{

   847         	iSettingDlg->SetSettingTextL( *settingPageTitle );	

   848         	}

   849 

   850         //Start listening if call occurs

   851         iPhoneSettingsEngine->SetNetSAObserver( *this );

   852         

   853         __GSLOGSTRING( "[CGSNetworkPlugin::ShowSettingPageL] Executing dialog" );

   854         const TInt res =

   855             iSettingDlg->ExecuteLD( CAknSettingPage::EUpdateWhenChanged );

   856         __GSLOGSTRING( "[CGSNetworkPlugin::ShowSettingPageL] Dialog closed" );

   857         iSettingDlg = NULL;

   858         // Get the feature id corresponding to array index

   859         const TGSNetworkModeItems currentFeature = IntToEnum( currentIndex );

   860 

   861         if ( res )

   862             {

   863             //not required for network mode UI item.

   864             //other items require calling this method.

   865             if ( aPage != EGSNetworkModeItemId )

   866                 {

   867                 CreateNetworkSsCallL( currentFeature, aPage );

   868                 }

   869             else if ( prevSelection != currentIndex )

   870                 {

   871                 // Show the confirmation query. Uses TGSNetworkModeItems.

   872                 Container()->SetCurrentNetworkModeSelectionL( currentFeature );

   873                 }

   874             }

   875         CleanupStack::PopAndDestroy( itemArray );

   876         }

   877     //We'll update listbox for Network Mode when we're sure that phone is not

   878     //in Offline mode

   879     if ( aPage != EGSNetworkModeItemId )

   880         {

   881         UpdateListBoxL( aPage );

   882         }

   883 

   884     CleanupStack::PopAndDestroy( settingPageTitle );

   885 

   886     __GSLOGSTRING( "[CGSNetworkPlugin::ShowSettingPageL] End" );

   887     }

   888 

   889 // ---------------------------------------------------------------------------

   890 //

   891 // utility for converting TInt to TGSNetworkModes enum.

   892 //

   893 // ---------------------------------------------------------------------------

   894 TGSNetworkModeItems CGSNetworkPlugin::IntToEnum( TInt aFeatureId )

   895     {

   896     TGSNetworkModeItems mode = EGSNetworkModeDualmode;

   897     TInt supportedNetworks = Container()->NetPluginModel()->GetSupportedNetworksL();

   898     TInt value = 0;

   899     

   900     switch( aFeatureId )

   901         {

   902         case EGSNetworkModeDualmode:

   903             mode = EGSNetworkModeDualmode;

   904             break;

   905         case EGSNetworkModeUMTS:

   906             value = supportedNetworks & CGSNetworkPluginContainer::ENetFirstBit;           

   907             if ( value ) 

   908                  {

   909                  mode = EGSNetworkModeUMTS;

   910                  }

   911              else

   912             //assume that only dual mode and gsm are possible.

   913                  {

   914                  mode = EGSNetworkModeGSM;

   915                  }

   916             break;

   917         case EGSNetworkModeGSM:

   918             mode = EGSNetworkModeGSM;

   919             break;

   920         default:

   921             // This should not happen as items should always have matching id.

   922             __ASSERT_DEBUG( EFalse, User::Panic( KGSNetworkPluginAssertName, KErrArgument ) );

   923         }

   924     return mode;

   925     }

   926 

   927 

   928 // ---------------------------------------------------------------------------

   929 //

   930 // If calls are started when in Network Setting Page, it is closed.

   931 //

   932 // ---------------------------------------------------------------------------

   933 void CGSNetworkPlugin::HandleCallActivatedL()

   934     {

   935     __GSLOGSTRING("[GS]--> CGSNetworkPlugin::HandleCallActivatedL");

   936 

   937     CGSNetworkPluginContainer* container = Container();

   938     if ( container )

   939         {

   940         const TInt currentFeatureId = container->CurrentFeatureId();

   941 

   942 		    if ( currentFeatureId != EGSNetworkModeSelectionItemId )

   943 		        {

   944 		        iPhoneSettingsEngine->CancelProcess();

   945 		        return;

   946 		        }

   947 		    iPhoneSettingsEngine->CancelProcess();

   948 		    //Close requesting notes

   949 		    if ( iDlg )

   950 		        {

   951 		        HandleSearchingNetworksL( MPsetNetworkInfoObserver::EServiceRequestNone );

   952 		        HandleRequestingSelectedNetworkL( EFalse );

   953 		        }

   954 

   955 		    //Close available network's list

   956 		    if ( iNetworkPopupList )

   957 		        {

   958 		        iNetworkPopupList->CancelPopup();

   959 		        iNetworkPopupList = NULL;

   960 		        }

   961 		    

   962 		    CloseDialog();

   963 		    

   964         }

   965     __GSLOGSTRING("[GS] <--CGSNetworkPlugin::HandleCallActivatedL");

   966     }

   967 

   968 // ---------------------------------------------------------------------------

   969 //

   970 // Handles errors.

   971 // From MPsetNetworkInfoObserver.

   972 // ---------------------------------------------------------------------------

   973 void CGSNetworkPlugin::HandleNetworkErrorL(

   974     const MPsetNetworkInfoObserver::TServiceRequest aRequest,

   975     const TInt aError )

   976     {

   977 

   978 #ifdef _DEBUG

   979     TBuf<KGSNetworkModeDebugStrLen> requestBuf;

   980     GSNetworkDebugHelper::NetworkInfoRequestToDes( aRequest, requestBuf );

   981     __GSLOGSTRING2( "[CGSNetworkPlugin::HandleNetworkErrorL] %S error:%d",

   982                     &requestBuf, aError );

   983 #endif // _DEBUG

   984 

   985     TInt resourceTxt = KErrNone;

   986     switch ( aRequest )

   987         {

   988         case MPsetNetworkInfoObserver::EServiceRequestGetNetworkInfo:

   989             iPhoneSettingsEngine->CancelProcess();

   990             iApprovedNetwork = EFalse;

   991             break;

   992         case MPsetNetworkInfoObserver::EServiceRequestSetNetworkAutomatic:

   993         case MPsetNetworkInfoObserver::EServiceRequestSetNetwork:

   994         default:

   995             break;

   996         }

   997 

   998     TBool ignore = EFalse;

   999 

  1000     switch ( aError )

  1001         {

  1002         case KErrGsmNetCauseCallActive:

  1003             ignore = ETrue; //do not show an error

  1004             break;

  1005         case KErrGsm0707NoNetworkService:

  1006             resourceTxt = R_NO_NETWORK_FOUND;

  1007             break;

  1008         case KErrGsmOfflineOpNotAllowed:

  1009             resourceTxt = R_OFFLINE_MODE;

  1010             break;

  1011         default:

  1012             resourceTxt = R_NO_NETWORK_ACCESS;

  1013             break;

  1014         }

  1015     if ( !ignore )

  1016         {

  1017         ShowNoteL( resourceTxt, KGSErrorNote );

  1018         iApprovedNetwork = EFalse;

  1019         }

  1020     __GSLOGSTRING("[GS] <--CGSNetworkPlugin::HandleNetworkErrorL");

  1021     }

  1022 

  1023 // ---------------------------------------------------------------------------

  1024 //

  1025 // Check if calls are active and show note if Nw-menu is tried to be opened

  1026 //

  1027 // ---------------------------------------------------------------------------

  1028 void CGSNetworkPlugin::CheckCallActiveL( TGSNetworkItemIds aItemId )

  1029     {

  1030     __GSLOGSTRING("[GS]--> CGSNetworkPlugin::CheckCallActiveL");

  1031     if ( iPhoneSettingsEngine->IsCallActive() == CPsetSAObserver::EPSetCallActive )

  1032         {

  1033         ShowNoteL( R_ONGOING_CALL, KGSErrorNote );

  1034         return;

  1035         }

  1036 

  1037     // Show network mode selection only if the mode value is already available!

  1038     if ( aItemId == EGSNetworkModeItemId && !iSettingDlg

  1039          && Container()->NetPluginModel()->GetNetworkMode()

  1040          != KGSNetworkModeCapsNotUpdated

  1041          )

  1042         {

  1043 #ifdef FF_POWER_SAVE            

  1044             if ( iPsmActive->Mode() == EPsmsrvModePowerSave )

  1045                 {

  1046                 // If PSM is on, block setting:

  1047                 DisplayBlockNoteL();

  1048                 }

  1049             else

  1050                 {

  1051 #endif // FF_POWER_SAVE                    

  1052                 ShowSettingPageL( EGSNetworkModeItemId );

  1053 #ifdef FF_POWER_SAVE

  1054                 }

  1055 #endif // FF_POWER_SAVE 

  1056         }

  1057     else if( !iSettingDlg         

  1058     	    //&& Container()->NetPluginModel()->GetNetworkMode()

  1059             /*!= KGSNetworkModeCapsNotUpdated*/ )

  1060         {

  1061         ShowSettingPageL( EGSNetworkModeSelectionItemId );

  1062         }

  1063     __GSLOGSTRING("[GS] <--CGSNetworkPlugin::CheckCallActiveL");

  1064     }

  1065 

  1066 // ---------------------------------------------------------------------------

  1067 //

  1068 // Sets a title to a given popup list.

  1069 //

  1070 // ---------------------------------------------------------------------------

  1071 void CGSNetworkPlugin::SetTitleToPopupL( CAknPopupList& aList, TInt aTitleID )

  1072     {

  1073     HBufC* text = StringLoader::LoadLC( aTitleID );

  1074     aList.SetTitleL( *text );

  1075     CleanupStack::PopAndDestroy( text );

  1076     text = NULL;

  1077     }

  1078 

  1079 // ---------------------------------------------------------------------------

  1080 //

  1081 // Sets a title to a settings page.

  1082 //

  1083 // ---------------------------------------------------------------------------

  1084 void CGSNetworkPlugin::SetTitleToSettingsL( CAknRadioButtonSettingPage& aDlg,

  1085                                               TInt aTitleID )

  1086     {

  1087     HBufC* title = StringLoader::LoadLC( aTitleID );

  1088     aDlg.SetSettingTextL( *title );

  1089     CleanupStack::PopAndDestroy( title );

  1090     title = NULL;

  1091     }

  1092 

  1093 // ---------------------------------------------------------------------------

  1094 //

  1095 // Appends given item to given list

  1096 //

  1097 // ---------------------------------------------------------------------------

  1098 void CGSNetworkPlugin::AppendItemL( CDesCArrayFlat& aList, TInt aItem )

  1099     {

  1100     HBufC* string = StringLoader::LoadLC( aItem );

  1101     aList.AppendL( *string );

  1102     CleanupStack::PopAndDestroy( string );

  1103     }

  1104 

  1105 // ---------------------------------------------------------------------------

  1106 //

  1107 // Shows a note if GPRS is active, when MCN is turned on.

  1108 //

  1109 // ---------------------------------------------------------------------------

  1110 void CGSNetworkPlugin::CheckGPRSConnectionL( TInt aCurrentItem )

  1111     {

  1112     if ( ( iPhoneSettingsEngine->IsGPRSConnected() ==

  1113                      CPsetSAObserver::EPSetGPRSConnectionActive )

  1114         && ( aCurrentItem == KGSSettingOff ) ) //if trying to set On...

  1115         {

  1116         ShowNoteL( R_ACTIVE_GPRS_CONN_NOTE, KGSInformationNote );

  1117         }

  1118     }

  1119 

  1120 // ---------------------------------------------------------------------------

  1121 //

  1122 // Set MCN value: off => on, on => off.

  1123 //

  1124 // ---------------------------------------------------------------------------

  1125 void CGSNetworkPlugin::SwitchOnOffValue( TInt& aValue )

  1126     {

  1127     if ( aValue == EGSMcnSetOn )

  1128         {

  1129         aValue = EGSMcnSetOff;

  1130         }

  1131     else

  1132         {

  1133         aValue = EGSMcnSetOn;

  1134         }