/*

* Copyright (c) 2006-2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Call submenu in General Settings.

*

*/

// INCLUDE FILES

#include "GSNetworkPlugin.h"         //for CGSCallPlugin

#include "GSNetworkPluginContainer.h"    //for CGSCallPluginContainer

#include "GsLogger.h"

#include "GSNetworkPlugin.h"             //for pluginUID

#include <coeaui.h>

#include <hlplch.h>                     // For HlpLauncher

//AVKON headers

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

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

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

#include <aknViewAppUi.h>               //for viewappui

#include <AknWaitDialog.h>              //for CAknWaitDialog

#include <AknIconArray.h>               //for AknIconArray

#include <StringLoader.h>               //for StringLoader

#include <apparc.h>

#include <gscommon.hrh>

//Phonesettings and TSY headers

#include <PsetContainer.h>              //for CPsetContainer

#include <PsetNetwork.h>                //for CPsetNetwork

#include <PsetSAObserver.h>             //for CPsetSAObserver

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

#include <exterror.h>

#include <featmgr.h>

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

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

#include <e32property.h>

#include <PSVariables.h>

#include <gsnetworkpluginrsc.rsg>           //for resource IDs

#include <gsfwviewuids.h>

#include <gslistbox.h>                  //for CGSListBoxItemTextArray

#include <e32property.h>

#include <PSVariables.h>

#include <gsprivatepluginproviderids.h>

#include <gsnetworkplugin.mbg>

#include <BTSapInternalPSKeys.h>

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

#include <activeidle2domainpskeys.h>

#include <CNWSession.h>

#include <NetworkHandlingProxy.h>

#include <gsparentplugin.h>

#include "GSNetworkDebugHelper.h"

#ifdef FF_POWER_SAVE

    #include "GSNetworkPluginAO.h"

#endif // FF_POWER_SAVE

// LOCAL CONSTANTS

_LIT( KGSNetWCDMAIcon, "0\t" );

_LIT( KGSNetGSMIcon, "1\t" );

_LIT( KEmptyStr, "" );

/* Implementation of forbidden operator icon begins */

_LIT( KGSNetNoIcon, "\t");

_LIT( KGSNetForbiddenIcon, "2\t" );

/* Implementation of forbidden operator icon ends */

// Warning disabled as this constant is used inside __ASSERT_DEBUG

#pragma diag_suppress 177

_LIT( KGSNetworkPluginAssertName, "CGSNetworkPlugin" );

// Middle Softkey control ID.

const TInt KGSMSKControlID = 3;

const TInt KGSNetIconAdditionalChars = 5;

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

// ---------------------------------------------------------------------------

//

// Constructor.

//

// ---------------------------------------------------------------------------

CGSNetworkPlugin::CGSNetworkPlugin()

    :iMskCommandFlag( ETrue ) , iPsmActive( NULL )

    {

    }

// ---------------------------------------------------------------------------

//

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

//

// ---------------------------------------------------------------------------

void CGSNetworkPlugin::ConstructL()

    {

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

    FeatureManager::InitializeLibL();

    OpenLocalizedResourceFileL( KGSNetworkPluginResourceFileName,

                                iResourceLoader );

    //PS listener initialization

    iBtSapListener = CGSPubSubsListener::NewL(

                     KPSUidBluetoothSapConnectionState,

                     KBTSapConnectionState, this );

    BaseConstructL( R_GS_NET_VIEW );

    iSettingsContainer = CPsetContainer::NewL();

    iPSRefreshHandler = iSettingsContainer->CreateRefreshHandlerL();

    iPSRefreshHandler->NotifyFileChangeL(

            *this,

            KCspEf,

            EFileChangeNotification );

    iPhoneSettingsEngine = iSettingsContainer->CreateNetworkObjectL( *this );

    iApprovedNetwork = EFalse;

    CheckAndCreateDlgL( EFalse );

    iSearchForNetworksActive = EFalse;

    iNetworkText = HBufC::NewL( KNWShortNameLength );

    UpdateNetworkTextL();

#ifdef FF_POWER_SAVE    

    iPsmActive = CGSNetworkPluginAO::NewL();

    iPsmActive->SetView( this );

#endif // FF_POWER_SAVE   

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

    }

// ---------------------------------------------------------------------------

//

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

//

// ---------------------------------------------------------------------------

CGSNetworkPlugin* CGSNetworkPlugin::NewLC()

    {

    CGSNetworkPlugin* self = new ( ELeave ) CGSNetworkPlugin;

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// ---------------------------------------------------------------------------

// CGSNetworkPlugin::NewL()

// Static constructor

//

// ---------------------------------------------------------------------------

//

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

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------------------------

//

// Destructor

//

// ---------------------------------------------------------------------------

CGSNetworkPlugin::~CGSNetworkPlugin()

    {

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

    FeatureManager::UnInitializeLib();

    if( iNWSession )

        {

        delete iNWSession;

        iNWSession = NULL;

        }

    if ( iBtSapListener )

        {

        delete iBtSapListener;

        iBtSapListener = NULL;

        }

    if ( iPhoneSettingsEngine )

        {

        if( iSearchForNetworksActive )

            {

            //Reset back to previously used network

            iPhoneSettingsEngine->ResetNetworkSearch();

            }

        delete iPhoneSettingsEngine;

        iPhoneSettingsEngine = NULL;

        }

    if ( iNetworkArray )

        {

        iNetworkArray->Reset();

        delete iNetworkArray;

        iNetworkArray = NULL;

        }

    if ( iDlg )

        {

        delete iDlg;

        iDlg = NULL;

        }

    if ( iNetworkPopupList )

        {

        iNetworkPopupList->CancelPopup();

        }

    CloseDialog();

    //Cancel any outstanding SAT notifications

    if ( iPSRefreshHandler )

        {

        iPSRefreshHandler->CancelNotify();

        delete iPSRefreshHandler;

        iPSRefreshHandler = NULL;

        }

    if( iSettingsContainer )

        {

        delete iSettingsContainer;

        iSettingsContainer = NULL;

        }

    delete iNetworkText;

    iNetworkText = NULL;

#ifdef FF_POWER_SAVE

    delete iPsmActive;

    iPsmActive = NULL;

#endif // FF_POWER_SAVE

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

    }

// ---------------------------------------------------------------------------

//

// Returns Id of the Network submenu

//

// ---------------------------------------------------------------------------

TUid CGSNetworkPlugin::Id() const

    {

    return KGSNetworkPluginUid;

    }

// ----------------------------------------------------------------------------

// CGSNetworkPlugin::Visible

//

// Provides the visibility status of self to framework.

// ----------------------------------------------------------------------------

//

TBool CGSNetworkPlugin::Visible() const

    {

    TBool result( EFalse );

    TInt value = 0;

    iBtSapListener->Get( value );

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

        {

        result = ETrue;

        }

    else

        {

        result = EFalse;

        }

    return result;

    }

// ---------------------------------------------------------------------------

//

// Handles network info

//

// ---------------------------------------------------------------------------

void CGSNetworkPlugin::HandleNetworkInfoReceivedL(

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

    {

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

    const TInt itemsCount = aInfoArray->Count();

    //first delete old ones

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

    //then insert found networks

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

        {

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

        iNetworkArray->InsertL( i, info );

        }

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

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

    }

// ---------------------------------------------------------------------------

//

// Creates list of Network providers

//

// ---------------------------------------------------------------------------

void CGSNetworkPlugin::NetworkListL()

    {

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

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

    TBool showGraphicalList =

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

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

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

    if ( iNetworkArray->Count() > 0 )

        {

        /** Implementation of forbidden operator icon begins */

        // check if forbidden operator icon is supported

        TBool forbiddenOperator = 

                FeatureManager::FeatureSupported( KFeatureIdFfTdScdmaForbiddenoperatoricondisplay );

        /** Implementation of forbidden operator icon ends */

        while ( !iApprovedNetwork )

            {

            AknPopupListEmpty<CEikFormattedCellListBox>* list;

            /** Implementation of forbidden operator icon begins */

            if (forbiddenOperator || showGraphicalList

                    && FeatureManager::FeatureSupported(KFeatureIdProtocolWcdma))

                {

                list = new (ELeave) CAknSingleGraphicPopupMenuStyleListBox;

                }

            else

                {

                list = new (ELeave) CAknSinglePopupMenuStyleListBox;

                }

            /** Implementation of forbidden operator icon ends */

            CleanupStack::PushL( list );

            if ( iNetworkPopupList )

                {

                iNetworkPopupList->CancelPopup();

                iNetworkPopupList = NULL;

                }

            iNetworkPopupList =

                CAknPopupList::NewL( list, R_AVKON_SOFTKEYS_OK_CANCEL );

            list->ConstructL( iNetworkPopupList,

                              CEikListBox::ELeftDownInViewRect );

            list->CreateScrollBarFrameL( ETrue );

            list->ScrollBarFrame()->SetScrollBarVisibilityL(

                CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto );

            //Fill in the list texts

            CDesCArrayFlat* items =

                new ( ELeave ) CDesCArrayFlat( KGSNetPopupMenuItems );

            CleanupStack::PushL( items );

            const TInt itemsCount = iNetworkArray->Count();

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

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

                {

                HBufC* insertString =

                    HBufC::NewLC(

                        KGSNwLongNameLength + KGSNetIconAdditionalChars );

                MPsetNetworkSelect::TNetworkInfo info =

                    iNetworkArray->At( loop );

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

                     info.iLongName.Length() > KGSNwLongNameLength )

                    {

                    //no names received, use IDs

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

                        info.iShortName.Length() > KGSNwShortNameLength )

                        {

                        TNetworkID ids;

                        TNetworkID networkCode;

                        ids = info.iId.iCountryCode;

                        ids.Append( KGSEmptySpace );

                        networkCode = info.iId.iNetworkCode;

                        ids.Append( networkCode );

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

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

                        }

                    //short name received

                    else

                        {

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

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

                        }

                    }

                //long name received

                else

                    {

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

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

                    }

                /** Implementation of forbidden operator icon begins */

                //set icon for network

                if ( forbiddenOperator )

                    {

                    if ( info.iStatus == MPsetNetworkSelect::ENetStatForbidden )

                        {

                        insertString->Des().Insert( 0, KGSNetForbiddenIcon );

                        }

                    else 

                        {

                        insertString->Des().Insert( 0, KGSNetNoIcon );

                        }

                    }

                else if ( showGraphicalList )

                    {

                    if ( FeatureManager::FeatureSupported(

                                                  KFeatureIdProtocolWcdma ) )

                        {

                        if ( info.iAccess !=

                             MPsetNetworkSelect::ENetNetworkGSM )

                            {

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

                            }

                        else

                            {

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

                            }

                        }

                    }

                /** Implementation of forbidden operator icon ends */

                items->AppendL( *insertString );

                CleanupStack::PopAndDestroy();

                }

            // For Testing purpuses ONLY

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

                {

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

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

                }

            CTextListBoxModel* model = list->Model();

            model->SetItemTextArray( items );

            model->SetOwnershipType( ELbmOwnsItemArray );

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

            //Set title for list

            SetTitleToPopupL( *iNetworkPopupList, R_NETSL_FOUNDOPERATORS );

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

            // based on the local variation

            /** Implementation of forbidden operator icon begins */

            if ( forbiddenOperator || showGraphicalList )

                {

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

                CleanupStack::PushL( iconList );

                iconList->ConstructFromResourceL( R_NET_DUALMODE_ICONS );

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

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

                }

            /** Implementation of forbidden operator icon ends */

            TInt res = 0;

            if( items->Count() )

                {

                res = iNetworkPopupList->ExecuteLD();

                }

            iNetworkPopupList = NULL;

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

            TInt selection = list->CurrentItemIndex();

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

            CleanupStack::PopAndDestroy( list );

            if ( res )

                {

                MPsetNetworkSelect::TNetworkInfo info =

                    iNetworkArray->At( selection );

                info.iMode = MPsetNetworkSelect::ENetSelectModeManual;

                iPhoneSettingsEngine->SelectNetworkL( info );

                }

            else // user selected "Cancel"

                {

                //Reset back to previously used network

                iPhoneSettingsEngine->ResetNetworkSearch();

                //After list has been used, clear it.

                PurgeNetworkList();

                if ( iPhoneSettingsEngine->IsCallActive() !=

                     CPsetSAObserver::EPSetCallActive )

                    {

                    ShowSettingPageL( EGSNetworkModeSelectionItemId );

                    }

                }

            }

        }

    iApprovedNetwork = EFalse; //initialize before new search

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

    }

// ---------------------------------------------------------------------------

//

// Handles requests to change network

//

// ---------------------------------------------------------------------------

void CGSNetworkPlugin::HandleNetworkChangedL(

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

    const MPsetNetworkSelect::TCurrentNetworkStatus /*aStatus*/,

    const TInt /*aResult*/ )

    {

    //DEPRECATED

    }

// ---------------------------------------------------------------------------

//

// Handles requests to change network

//

// ---------------------------------------------------------------------------

void CGSNetworkPlugin::HandleNetworkChangedL(

    const MPsetNetworkSelect::TNetworkInfo& aCurrentInfo,

    const RMobilePhone::TMobilePhoneRegistrationStatus& aStatus,

    const TInt /* aResult */ )

    {

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

    switch ( aStatus )

        {

        case RMobilePhone::ERegisteredOnHomeNetwork:

            ShowNoteL( R_HOME_NETWORK_SELECTED, KGSConfirmationNote );