/*

* Copyright (c) 2002-2005 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:  CPsetNetwork selects network and gets network information.

*

*

*/

//  INCLUDE FILES

#include "CNetworkResetHandler.h"

#include "MPsetNetworkInfoObs.h"

#include "MPsetNetworkSelect.h"

#include "PsetNetwork.h"

#include "PsetSAObserver.h"     

#include "PSetPanic.h"          

#include "PsetConstants.h"

#include "PhoneSettingsLogger.h"

#include <etelmm.h>

#include <mmretrieve.h>

#include <rmmcustomapi.h>

#include <e32svr.h>

//  LOCAL CONSTANTS AND MACROS  

_LIT( KPSNameOfClass, "CPsetNetwork" );

enum TActiveObserver

    {

    ENetSelectObserver,

    ENetModeObserver

    };

//  MEMBER FUNCTIONS

//=============================================================================

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

// 

// 1st phase constructor.

// 

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

//

EXPORT_C CPsetNetwork* CPsetNetwork::NewL( RMobilePhone& aPhone, 

    MPsetNetworkInfoObserver& aObserver )

    {

    CPsetNetwork* self = new ( ELeave ) CPsetNetwork( aPhone );

    CleanupStack::PushL( self );

    self->ConstructL( aObserver );

    CleanupStack::Pop( self );

    return self;

    }

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

// 

// 1st phase constructor for net mode observer.

// 

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

//

EXPORT_C CPsetNetwork* CPsetNetwork::NewL( RMobilePhone& aPhone, 

                       MPsetNetworkModeObserver& aModeObserver )

    {

    CPsetNetwork* self = new ( ELeave ) CPsetNetwork( aPhone );

    CleanupStack::PushL( self );

    self->ConstructL( aModeObserver );

    CleanupStack::Pop( self );

    return self;

    }

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

// 

// Destructor.

// 

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

//

EXPORT_C CPsetNetwork::~CPsetNetwork()

    {

    Cancel();

    iCustomPhone.Close();

    delete iNetworkRetrieve;

    iNetworkRetrieve = NULL;

    delete iSAObserver;

    iSAObserver = NULL;

    delete iResetNetworkSearch;

    iResetNetworkSearch = NULL;    

    } 

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

// 

// Returns available networks

// 

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

//

EXPORT_C void CPsetNetwork::GetAvailableNetworksL()

    {

    __PHSLOGSTRING("[PHS]--> CPsetNetwork::GetAvailableNetworksL");

    if ( IsActive() )

        {

        User::Leave( KErrInUse );

        }

    if ( iNetworkRetrieve )

        {

        delete iNetworkRetrieve;

        iNetworkRetrieve = NULL;

        }

    // Start to request for network information.

    iNetworkRetrieve = CRetrieveMobilePhoneDetectedNetworks::NewL( iPhone );

    iNetworkRetrieve->StartV2( iStatus );    

    iServiceRequest = MPsetNetworkInfoObserver::EServiceRequestGetNetworkInfo;

    SetActive();

    // Show searching note.

    CleanupLeavePushL();

    iObserver->HandleSearchingNetworksL( iServiceRequest );

    CleanupStack::Pop(); // CleanupCancelPushL

    __PHSLOGSTRING("[PHS] <--CPsetNetwork::GetAvailableNetworksL");

    }

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

// 

// Returns information of the currently selected network.

// DEPRECATED.

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

//

EXPORT_C TInt CPsetNetwork::GetCurrentNetworkInfo

                ( MPsetNetworkSelect::TCurrentNetworkInfo& /*aInfo*/ )

    {

    return KErrNotSupported;

    }

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

// 

// Retrieve current search mode (automatic or manual)

// 

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

//

EXPORT_C TInt CPsetNetwork::GetNetworkSelectMode( TSelectMode& aMode )

    {

    RMobilePhone::TMobilePhoneNetworkSelectionV1 setMode;

    RMobilePhone::TMobilePhoneNetworkSelectionV1Pckg setModePckg( setMode );

    __PHSLOGSTRING("[PHS]--> CPsetNetwork::GetNetworkSelectMode");

    TInt res( iPhone.GetNetworkSelectionSetting( setModePckg ) );

    if ( res == KErrNone )

        {

        if ( setMode.iMethod == RMobilePhone::ENetworkSelectionAutomatic )

            {

            aMode = ENetSelectModeAutomatic;

            }

        else

            {

            aMode = ENetSelectModeManual;

            }

        iTempNetInfo.iMode = aMode;

        }

    __PHSLOGSTRING("[PHS] <--CPsetNetwork::GetNetworkSelectMode");

    return res;

    }

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

// 

// Starts using the indicated network.

// 

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

//

EXPORT_C void CPsetNetwork::SelectNetworkL( const TNetworkInfo& aInfo )

    {

    __PHSLOGSTRING("[PHS]--> CPsetNetwork::SelectNetworkL");

    if ( IsActive() )

        {

        User::Leave( KErrInUse );

        }    

    //Save previous network mode.

    TBool previousModeAutomatic = EFalse;

    if ( iTempNetInfo.iMode == ENetSelectModeAutomatic )

        {

        previousModeAutomatic = ETrue;

        }

    iTempNetInfo = aInfo;

    if ( aInfo.iMode == ENetSelectModeManual )

        {        

        //Copy data to member variables and make a request.

        iNwInfo.iCountry.Append( aInfo.iId.iCountryCode );

        __PHSLOGSTRING1("[PHS]   CPsetNetwork::SelectNetworkL: Manual - CountryCode: %S", &aInfo.iId.iCountryCode);

        iNwInfo.iNetwork.Append( aInfo.iId.iNetworkCode );        

        __PHSLOGSTRING1("[PHS]   CPsetNetwork::SelectNetworkL: Manual - NetworkCode: %S", &aInfo.iId.iNetworkCode);

        iServiceRequest = MPsetNetworkInfoObserver::EServiceRequestSetNetwork;

        iPhone.SelectNetwork( iStatus, ETrue, iNwInfo );

        }

    else

        {

        iServiceRequest = 

            MPsetNetworkInfoObserver::EServiceRequestSetNetworkAutomatic;

        //If previously automatic, and now automatic, issue request

        // to search networks.

        if ( previousModeAutomatic )

            {

            iNwInfo.iCountry.Append( aInfo.iId.iCountryCode );            

            __PHSLOGSTRING1("[PHS]   CPsetNetwork::SelectNetworkL: Auto - CountryCode: %S", &aInfo.iId.iCountryCode);

            iNwInfo.iNetwork.Append( aInfo.iId.iNetworkCode );

            __PHSLOGSTRING1("[PHS]   CPsetNetwork::SelectNetworkL: Auto - NetworkCode: %S", &aInfo.iId.iNetworkCode);

            iPhone.SelectNetwork( iStatus, EFalse, iNwInfo );

            }

        // make new selection without Network/Country code this way device 

        // connects automatically home network.

        else

            {    

            iNwInfo.iCountry = KNullDesC;

            iNwInfo.iNetwork = KNullDesC;

            __PHSLOGSTRING("[PHS]   CPsetNetwork::SelectNetworkL: Manual>Auto - CountryCode = KNullDesC");

            __PHSLOGSTRING("[PHS]   CPsetNetwork::SelectNetworkL: Manual>Auto - NetworkCode = KNullDesC");

            iPhone.SelectNetwork( iStatus, EFalse, iNwInfo );

            }

        }    

    SetActive();

    //Show requesting note.

    CleanupLeavePushL();    

    if ( aInfo.iMode == ENetSelectModeManual )

        {

        __PHSLOGSTRING("[PHS]--> CPsetNetwork::SelectNetworkL: Requesting Selected N/W");

        iObserver->HandleRequestingSelectedNetworkL( ETrue );

        }

    else

        {

        __PHSLOGSTRING("[PHS]--> CPsetNetwork::SelectNetworkL: Searching N/Ws");

        iObserver->HandleSearchingNetworksL( iServiceRequest );

        }    

    CleanupStack::Pop(); // CleanupCancelPushL

    __PHSLOGSTRING("[PHS] <--CPsetNetwork::SelectNetworkL");

    }

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

// 

// Running the active object

// 

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

//

void CPsetNetwork::RunL()

    {

    __PHSLOGSTRING1("[PHS]--> CPsetNetwork::RunL() - iStatus = %d", iStatus.Int());

    MPsetNetworkInfoObserver::TServiceRequest serviceRequest = iServiceRequest;

    MPsetNetworkModeObserver::TServiceRequest modeRequest = iModeRequest;

    // Params have to be cleared here since the observer may initiate another asynchronous operation immediately

    // after they are notified, effectively messing up the state machine which controls the logic in DoCancel()

    // resulting in a possible dead lock when CActive::Cancel()'s User::WaitForRequest( iStatus ) never gets signaled.

    ClearParams();

    if ( iActiveObserver == ENetSelectObserver )

        {

        __ASSERT_ALWAYS( iObserver, Panic( KPSNameOfClass, ENetNoObserver ) );

        HideRequestNoteL();

        }

    else if ( iActiveObserver == ENetModeObserver )

        {        

        __ASSERT_ALWAYS( iNetworkModeObserver, 

                     Panic( KPSNameOfClass, ENetNoNetworkObserver  ) );

        }

    if ( iStatus != KErrNone )

        {

        if ( modeRequest == 

              MPsetNetworkModeObserver::EServiceRequestSetSelectedNetworkMode || 

             modeRequest == 

              MPsetNetworkModeObserver::EServiceRequestGetCurrentNetworkMode )

            {

            __PHSLOGSTRING("[PHS]--> CPsetNetwork::RunL: Request is modeRequest");

            //PSetNetworkModeObs

            iNetworkModeObserver->HandleNetworkErrorL( modeRequest, iStatus.Int() );

            }

        else

            {

            __PHSLOGSTRING("[PHS]--> CPsetNetwork::RunL: Request is serviceRequest");

            //PSetNetworkInfoObs

            GetRegistrationStatusL();

            iObserver->HandleNetworkErrorL( serviceRequest, iStatus.Int() );

            }

        } 

    else // Request completed successfully.

        {

        switch ( serviceRequest )

            {

            case MPsetNetworkInfoObserver::EServiceRequestGetNetworkInfo:

                {

                CNetworkInfoArray* array = new ( ELeave ) 

                    CNetworkInfoArray( KPSetNetworkInfoArrayGranularity );

                CleanupStack::PushL( array );

                CMobilePhoneNetworkListV2* results = 

                    iNetworkRetrieve->RetrieveListV2L();

                CleanupStack::PushL( results );

                TInt amount = results->Enumerate();

                __PHSLOGSTRING1("[PHS]   CPsetNetwork::RunL: amount: %d", amount);

                TInt i = 0;

                RMobilePhone::TMobilePhoneNetworkInfoV2 nwNames;

                while ( amount > i ) 

                    {

                    nwNames = results->GetEntryL( i );

                    iTempNetInfo.iId.iCountryCode.Copy( nwNames.iCountryCode );

                    __PHSLOGSTRING1("[PHS]   CPsetNetwork::RunL: CountryCode: %S", &iTempNetInfo.iId.iCountryCode);

                    iTempNetInfo.iId.iNetworkCode.Copy( nwNames.iNetworkId );

                    __PHSLOGSTRING1("[PHS]   CPsetNetwork::RunL: NetworkCode: %S", &iTempNetInfo.iId.iNetworkCode);

                    iTempNetInfo.iLongName.Copy( nwNames.iLongName );

                    __PHSLOGSTRING1("[PHS]   CPsetNetwork::RunL: LongName: %S", &iTempNetInfo.iLongName);

                    iTempNetInfo.iShortName.Copy( nwNames.iShortName );

                    __PHSLOGSTRING1("[PHS]   CPsetNetwork::RunL: ShortName: %S", &iTempNetInfo.iShortName);

                    if ( nwNames.iAccess == RMobilePhone::ENetworkAccessUtran )

                        {

                        iTempNetInfo.iAccess = ENetNetworkWCDMA;

                        }

                    else

                        {

                        iTempNetInfo.iAccess = ENetNetworkGSM;

                        }

                    array->AppendL( iTempNetInfo );

                    i++;       

                    }

                CleanupStack::PopAndDestroy( results );

                results = NULL;

                __PHSLOGSTRING1("[PHS]   CPsetNetwork::RunL: Count: %d", array->Count());

                iObserver->HandleNetworkInfoReceivedL( array, KErrNone );

                CleanupStack::PopAndDestroy( array );

                array = NULL;

                break;        

                }

            case MPsetNetworkInfoObserver::EServiceRequestSetNetwork:

                {

                __PHSLOGSTRING("[PHS]   CPsetNetwork::RunL: EServiceRequestSetNetwork");

                GetRegistrationStatusL();

                iObserver->HandleNetworkChangedL( iTempNetInfo,

                    iRegStatus, KErrNone );

                break;

                }

            default:

                break;

            }

        //check if this is correct

        switch ( modeRequest )

            {

            case MPsetNetworkModeObserver::EServiceRequestSetSelectedNetworkMode:

                __PHSLOGSTRING("[PHS]   CPsetNetwork::RunL: EServiceRequestSetSelectedNetworkMode");

                iNetworkModeObserver->HandleNetworkSystemModeEventsL( 

                                                       modeRequest,

                                                       iNetworkModeCaps );

                break;

            case MPsetNetworkModeObserver::EServiceRequestGetCurrentNetworkMode:

                __PHSLOGSTRING("[PHS]   CPsetNetwork::RunL: EServiceRequestGetCurrentNetworkMode");

                iNetworkModeObserver->HandleNetworkSystemModeEventsL( 

                                                       modeRequest,

                                                       iNetworkModeCaps );

                break;            

            default:

                break;

            }

        }

    __PHSLOGSTRING("[PHS] <--CPsetNetwork::RunL");

    }

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

// 

// Cancels pending request

// 

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

//

void CPsetNetwork::DoCancel()

    {

    __PHSLOGSTRING("[PHS]--> CPsetNetwork::DoCancel");

    switch ( iServiceRequest )

        {

        case MPsetNetworkInfoObserver::EServiceRequestGetNetworkInfo:

            iNetworkRetrieve->Cancel();

            delete iNetworkRetrieve;

            iNetworkRetrieve = NULL;

            break;

        case MPsetNetworkInfoObserver::EServiceRequestSetNetwork:

        case MPsetNetworkInfoObserver::EServiceRequestSetNetworkAutomatic:

            iPhone.CancelAsyncRequest( EMobilePhoneSelectNetwork );

            break;

        default:            

            break;

        }

    switch ( iModeRequest )

        {

        case MPsetNetworkModeObserver::EServiceRequestSetSelectedNetworkMode:

            iCustomPhone.CancelAsyncRequest( ECustomSetSystemNetworkModeIPC );

            break;

        case MPsetNetworkModeObserver::EServiceRequestGetCurrentNetworkMode:

            __PHSLOGSTRING("[PHS]--> CPsetNetwork::EServiceRequestGetCurrentNetworkMode");

            iCustomPhone.CancelAsyncRequest( 

                ECustomGetCurrentSystemNetworkModesIPC );

            __PHSLOGSTRING("[PHS]--> CPsetNetwork::EServiceRequestGetCurrentNetworkMode 2");

            break;

        default:

            break;

        }

    ClearParams();

    __PHSLOGSTRING("[PHS] <--CPsetNetwork::DoCancel");

    }

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

// 

// Cancels current request

// 

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

//

EXPORT_C void CPsetNetwork::CancelProcess()

    {

    if ( !IsActive() )

        {

        //if not active, might mean that network list is shown, 

        // but call is incoming do not leave or raise error.

        }

    Cancel();

    }

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

// 

// Sets observer (Observer starts to listen again if reset).

// 

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

//

EXPORT_C void CPsetNetwork::SetNetSAObserver( MPsetNetworkInfoObserver& aObserver )

    {

    __ASSERT_ALWAYS( iSAObserver, Panic( KPSNameOfClass, ENetNoObserver ) );

    iSAObserver->SetNetObserver( aObserver );

    }

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

// 

// Adds this to scheduler

// 

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

//

void CPsetNetwork::ConstructL( MPsetNetworkInfoObserver& aObserver )

    {

    iObserver = &aObserver;

    iActiveObserver = ENetSelectObserver;

    iRegStatus = RMobilePhone::ERegistrationUnknown;

    User::LeaveIfError( iCustomPhone.Open( iPhone ) );

    iSAObserver = CPsetSAObserver::NewL();

    CActiveScheduler::Add( this );

    iResetNetworkSearch = CNetworkResetHandler::NewL( iPhone );

    }

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

// 

// Adds this to scheduler

// 

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

//

void CPsetNetwork::ConstructL( MPsetNetworkModeObserver& aModeObserver )

    {

    iNetworkModeObserver = &aModeObserver;

    iActiveObserver = ENetModeObserver;

    User::LeaveIfError( iCustomPhone.Open( iPhone ) );

    CActiveScheduler::Add( this );

    iResetNetworkSearch = CNetworkResetHandler::NewL( iPhone );

    }

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

// 

// C++ constructor.

// 

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

//

CPsetNetwork::CPsetNetwork

                ( RMobilePhone& aPhone ) : CActive( EPriorityStandard ),

                                           iPhone ( aPhone )

    {

    }

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

// 

// Gets registration status.

// 

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

//

void CPsetNetwork::GetRegistrationStatusL()

    {

    TRequestStatus status;

    iPhone.GetNetworkRegistrationStatus( status, iRegStatus );

    __PHSLOGSTRING1("[PHS]   CPsetNetwork::GetRegistrationStatusL: iRegStatus: %d", iRegStatus);

    User::WaitForRequest( status );

    User::LeaveIfError(status.Int());

    }

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

// 

// Requests SAObserver to check if call is active.

//