/*

* Copyright (c) 2002-2009 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:  This module contains the implementation of CNWNetworkViagBaseEngine

*                class member functions.

*

*/

// INCLUDE FILES

#include    <ctsydomainpskeys.h> 

#include    <e32property.h>

#include    <PSVariables.h>

#include    <startupdomainpskeys.h>

#include    "CNWNetworkViagBaseEngine.h"

#include    "CNWNetworkViagCbEngine.h"

#include    "CNWNetworkViagLcEngine.h"

#include    "NWLogger.h"

#include    "CNWNetworkViagRefresh.h"

#include    "CNWNetworkViagSimReader.h"

#include    "CNWNetworkSystemEventMonitor.h"

#include    "CNWGsmMessageHandler.h"

#include    "NWPanic.pan"

#include    "CNWNetworkViagTimer.h"

// CONSTANTS

const TUint KNWzero = 0;

const TInt KArrayCount = 8;

const TInt KNWTimeOut = 2000000;

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

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

// CNWNetworkViagBaseEngine::CNWNetworkViagBaseEngine

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CNWNetworkViagBaseEngine::CNWNetworkViagBaseEngine(

        CNWGsmNetworkCellReselectionHandler& aOwner,

        CNWGsmMessageHandler& aMessageHandler,

        RMmCustomAPI& aCustomAPI,

        TNWInfo& aNetworkInfo,

        TNWInterInfo& aInterNetworkInfo

         ):

           iOwner ( aOwner ),

           iMessageHandler( aMessageHandler ),

           iCustomAPI( aCustomAPI ),

           iNWNetworkInfo( aNetworkInfo ),

           iInterNetworkInfo( aInterNetworkInfo ),

           iLcSupported ( EFalse ),

           iCbActivation( EFalse ),

           iSimOk ( EFalse ),

           iActivation( EFalse ),

           iInitReady( ),

           iReadingOnGoing( EFalse )

    {

    NWLOGSTRING( KNWOBJECT, 

        "NW: CNWNetworkViagBaseEngine::CNWNetworkViagBaseEngine() Called." );

    }

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

// CNWNetworkViagBaseEngine::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CNWNetworkViagBaseEngine::ConstructL()

    {

    NWLOGSTRING( KNWOBJECT, 

        "NW: CNWNetworkViagBaseEngine::ConstructL() Begin." );

    RProperty::TType type( RProperty::EInt );

    TSecurityPolicy readPolicy( ECapability_None );

    TSecurityPolicy writePolicy( ECapabilityWriteDeviceData );

    TInt err = RProperty::Define( KPSUidNetworkInfo, 

                                KNWHomeZoneStatus, 

                                type, 

                                readPolicy, 

                                writePolicy );

    //An error of KErrAlready exists should be ignored, as this only

    //indicates that some other code int system is also interested in the 

    //value and has created the property.

    if ( err != KErrNone && err != KErrAlreadyExists )

        {

        NWLOGSTRING2( KNWERROR, "NW: CNWNetworkViagBaseEngine::ConstructL \

                RProperty::Define error: %d .", err );

        User::Leave( err );

        }    

    RProperty::Set( KPSUidNetworkInfo, KNWHomeZoneStatus, ENWNone );

    iSimStateMonitor = CNWNetworkSystemEventMonitor::NewL( *this,  

                                                        KPSUidStartup, 

                                                        KPSSimStatus ); 

    iCallStateMonitor = CNWNetworkSystemEventMonitor::NewL( 

            *this, KPSUidCtsyCallInformation, KCTsyCallState );    

    iGPRSStateMonitor = CNWNetworkSystemEventMonitor::NewL( 

            *this, KUidSystemCategory,KPSUidGprsStatusValue );

    iViagCbEngine = CNWNetworkViagCbEngine::NewL( *this, 

                                                iNWNetworkInfo, 

                                                iCustomAPI, 

                                                iInterNetworkInfo, 

                                                iOwner );

   // Sim status monitor.

    iViagSimReader = CNWNetworkViagSimReader::NewL( *this,  iCustomAPI );

    iViagLcEngine = CNWNetworkViagLcEngine::NewL( *this, 

                                                iNWNetworkInfo, 

                                                iCustomAPI, 

                                                iInterNetworkInfo );

    iZoneTags = new ( ELeave ) CZoneTagsArray( 1 );

    iZoneTags->ResizeL( KArrayCount );

    iSPNEFRead = ETrue;

    iNPNEFRead = ETrue;

    iProgEFRead = ETrue;

    iViagEFRead = ETrue;

    iTimer = CNWNetworkViagTimer::NewL();

    NWLOGSTRING( KNWOBJECT, 

        "NW: CNWNetworkViagBaseEngine::ConstructL() End." );

    }

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

// CNWNetworkViagBaseEngine::NewL

// Two-phased constructor.

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

//

CNWNetworkViagBaseEngine* CNWNetworkViagBaseEngine::NewL(

                CNWGsmNetworkCellReselectionHandler& aOwner,

                CNWGsmMessageHandler& aMessageHandler,

                RMmCustomAPI& aCustomAPI,

                TNWInfo& aNetworkInfo,

                TNWInterInfo& aInterNetworkInfo

                )

    {

    NWLOGSTRING( KNWOBJECT, 

        "NW: CNWNetworkViagBaseEngine::NewL() Begin." );

    CNWNetworkViagBaseEngine* self = new (ELeave) CNWNetworkViagBaseEngine( 

            aOwner, aMessageHandler, aCustomAPI, aNetworkInfo, 

            aInterNetworkInfo );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    NWLOGSTRING( KNWOBJECT, 

        "NW: CNWNetworkViagBaseEngine::NewL() End." );

    return self;

    }

// Destructor

CNWNetworkViagBaseEngine::~CNWNetworkViagBaseEngine()

    {

    NWLOGSTRING( KNWOBJECT, 

        "NW: CNWNetworkViagBaseEngine::~CNWNetworkViagBaseEngine() Begin." );

    delete iCharacterSetConverter;

    iFs.Close();

    delete iViagRefresh;

    delete iZoneTags;

    delete iViagLcEngine;

    delete iViagSimReader;

    delete iViagCbEngine;

    delete iGPRSStateMonitor;

    delete iCallStateMonitor;

    delete iSimStateMonitor;

    StopTimer();

    delete iTimer;

    NWLOGSTRING( KNWOBJECT, 

        "NW: CNWNetworkViagBaseEngine::~CNWNetworkViagBaseEngine() End." );

    }

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

// CNWNetworkViagBaseEngine::CellReselection

// Is called by CNWNetworkCurrentNetworkMonitor in case of cell re-selection.

// (other items were commented in a header).

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

//

void CNWNetworkViagBaseEngine::CellReselection()

    {

    NWLOGSTRING( KNWOBJECT,

        "NW: CNWNetworkViagBaseEngine::CellResection() Begin" );

    // SIM OK

    // VIAG IMSI OK

    // System UP ...

    NWLOGSTRING2( KNWOBJECT, "NW: CNWNetworkViagBaseEngine::CellResection \

                        iSimOk = %d ", iSimOk );

    // Sim is ok and imsi is right

    if ( iSimOk && IsViagImsi() )

        {

        // ... System is ready to proceed with HomeZone algoritmh(s)!!

        if ( iInitReady == EInitReady )

            {

            iViagActiveAlgo = EWNAlgoNone ;

            NWLOGSTRING( KNWOBJECT, 

                "NW: CNWNetworkViagBaseEngine::CellReselection StopCbAlgo()" );

            iViagCbEngine->StopCbAlgo();

            //  general activation is in default ETrue and CB activation EFalse   

            iViagLcEngine->GetActivation( iActivation, iCbActivation );

            NWLOGSTRING3( KNWOBJECT, 

                "NW: CNWNetworkViagBaseEngine::CellResection \

                iActivation = %d, iCbActivation = %d ", 

                iActivation, iCbActivation );

            NWLOGSTRING2( KNWOBJECT, 

                "NW: CNWNetworkViagBaseEngine::CellResection \

                iNetworkMode = %d", iNWNetworkInfo.iNetworkMode );

            if ( iActivation )

                {

                if ( iNWNetworkInfo.iNetworkMode == ENWModeWcdma )  // Network mode is WCDMA AND

                    {

                    if( iLcSupported )

                        {

                        iViagActiveAlgo = EWNAlgoLc ;    // UICC is "new geration" O2 de UICC    

                        }

                    }

                else  // GSM                                                                                // Network mode is GSM 

                    {

                    // Gsm mode + there is NOT gsm cells subscribed in LAC files

                    // Gsm mode + Cb-activation bit is "ON"

                    // Gsm mode + UICC is NOT "new geration" O2 de UICC 

                    iViagActiveAlgo = EWNAlgoCb ;       

                    if ( iViagLcEngine->IsGsmCellSubscribed()  )  // There is subscribed  gsm cells in LAC files.

                        {

                        if ( !iCbActivation )   // AND Cb-activation bit is off.

                            {

                            iViagActiveAlgo = EWNAlgoLc ;           

                            }                   

                        }

                    }

                }

            NWLOGSTRING2( KNWOBJECT, 

                "NW: CNWNetworkViagBaseEngine::CellReselection(),\

                iAreaKnown = %d",iInterNetworkInfo.iAreaKnown );

            // Reset  the indications

            WriteViagValues( ENWViagIndicatorTypeNone, KNWzero ); 

            if ( iNWNetworkInfo.iStatus == ENWStatusCurrent 

                 && iInterNetworkInfo.iAreaKnown )

                {

                if ( iViagActiveAlgo == EWNAlgoLc )

                    {

                    NWLOGSTRING( KNWOBJECT, 

                        "NW: CNWNetworkViagBaseEngine::ACTIVE ALGO ***LC***" );

                    iViagLcEngine->CellReselection();

                    }

                else if( iViagActiveAlgo == EWNAlgoCb )

                    {

                    NWLOGSTRING( KNWOBJECT, 

                        "NW: CNWNetworkViagBaseEngine::ACTIVE ALGO ***CB***" );

                    iViagCbEngine->CellReselection();

                    }

                else if ( iViagActiveAlgo == EWNAlgoNone )

                    {

                    NWLOGSTRING( KNWOBJECT, 

                        "NW: CNWNetworkViagBaseEngine::ACTIVE ALGO ***NONE***" );

                    }

                }

            }

        // ... System is NOT yet fully initialised

        else if( iInitReady == EInitNotReady && !iCharacterSetConverter ) 

            {

            TRAP_IGNORE( InitializeCharSetConverterL() );

            NWLOGSTRING( KNWOBJECT, "NW: CNWNetworkViagBaseEngine::CellResection \

                    System is NOT yet fully initialised " );

            ViagInitialize(); 

            // Sat server is not up in startup 

            iActiveCall = EFalse;

            }

        }

    NWLOGSTRING( KNWOBJECT, 

        "NW: CNWNetworkViagBaseEngine::CellResection() End" );

    }

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

// CNWNetworkViagBaseEngine::SatRefreshCompleteNotification

// Gets called when satrefresh is complete.

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

//   

void CNWNetworkViagBaseEngine::SatRefreshCompleteNotification()

    {

    NWLOGSTRING( KNWOBJECT, 

        "NW: CNWNetworkViagBaseEngine::SatRefreshCompleteNo\

        tification() Begin" );

    // When the HZ file of caches are refreshed then notify CB-Engine.

    if( iViagCbEngine )

        {

        iViagCbEngine->SatRefreshCompleteNotification(); 

        }

    NWLOGSTRING( KNWOBJECT, 

        "NW: CNWNetworkViagBaseEngine::SatRefreshCompleteNotification end" );

    }

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

// CNWNetworkViagBaseEngine::ViagInitialize

// Initialize viag elements files.

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

//   

void CNWNetworkViagBaseEngine::ViagInitialize()

    {               

    NWLOGSTRING( KNWOBJECT, 

            "NW: CNWNetworkViagBaseEngine::ViagInitialize() Begin" );

    iInitReady = EInitOngoing;

    // In start up read all elementary files that are needed.

    if ( iViagSimReader )

        {

        iViagSimReader->SetElementFile( EFileSettings );

        iViagSimReader->SetElementFile( EFileSubscribedOne );

        iViagSimReader->SetElementFile( EFileSubscribedTwo );

        iViagSimReader->SetElementFile( EFileSubscribedThree );

        iViagSimReader->SetElementFile( EFileSubscribedFour );

        iViagSimReader->SetElementFile( EFileTags );

        iViagSimReader->ReadSimFile();   

        }

    NWLOGSTRING( KNWOBJECT, 

            "NW: CNWNetworkViagBaseEngine::ViagInitialize() Complete" );

    }

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

// CNWNetworkViagBaseEngine::UpdateCache

// Update cache

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

//   

TBool CNWNetworkViagBaseEngine::UpdateCache( 

        TNWNetworkElementFile aElementFile, 

        const TDesC8& aResponse )

    {

    NWLOGSTRING2( KNWOBJECT, 

        "NW: CNWNetworkViagBaseEngine::UpdateCache() Begin\

        , aElementFile = 0x%x", aElementFile );  

    NWLOGSTRING2( KNWINT,

        "NW: CNWNetworkViagBaseEngine::UpdateCache(),\

        iActivation = %d", iActivation ); 

    ASSERT( iViagLcEngine );

    ASSERT( iViagCbEngine );

    if( iViagLcEngine )

        {

        if ( aElementFile == EFileSettings ||

                ( aElementFile != EFileSettings && iActivation ) )

            {

            iViagLcEngine->ParseResult( aElementFile ,  aResponse );

            if ( !iActivation )

                {

                iViagLcEngine->GetActivation( iActivation, iCbActivation );

                }

            if ( aElementFile == EFileTags && iInitReady == EInitOngoing )

                {

                iInitReady = EInitReady;

                if( iViagCbEngine )

                    {

                    iViagCbEngine->InitilizeCaches();

                    iViagCbEngine->UpdateViagHzParams();

                    }

                }

            }

        }

    NWLOGSTRING2( KNWOBJECT, "NW: CNWNetworkViagBaseEngine::UpdateCache() \

            End, length of aResponse = %d", aResponse.Length() );

    return iActivation;    

    }

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

// CNWNetworkViagBaseEngine::SetLcNotSupported

// Set LC support to False.

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

//   

void  CNWNetworkViagBaseEngine::SetLcSupported( TBool aLcSupported )

    {

    NWLOGSTRING2( KNWOBJECT, 

        "NW: CNWNetworkViagBaseEngine::SetLcSupported() \

        Begin, iLcSupported = %d  ", aLcSupported );

    ASSERT( iViagLcEngine );

    ASSERT( iViagCbEngine );

    iLcSupported = aLcSupported;

    if ( iLcSupported == EFalse )

        {

        iInitReady = EInitReady;

        if ( !iActivation )

            {

            iViagLcEngine->GetActivation( iActivation, iCbActivation );

            }

        if( iViagCbEngine && iActivation )

            {

            iViagCbEngine->InitilizeCaches();

            iViagCbEngine->UpdateViagHzParams();

            // If cell information is allready avaiable call cell reselection.

             if ( iInterNetworkInfo.iCellId != 0 )

                {

                CellReselection();       

                }

            }

        }

    NWLOGSTRING( KNWOBJECT, 

        "NW: CNWNetworkViagBaseEngine::SetLcSupported() end" );

    }

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

// CNWNetworkViagBaseEngine::SendMessage

// Reroutes a message to the Client object.

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

// 

void CNWNetworkViagBaseEngine::SendMessage(

        MNWMessageObserver::TNWMessages aMessage ) // send message

    {

    NWLOGSTRING2( KNWOBJECT, 

        "NW: CNWNetworkViagBaseEngine::SendMessage(),\

         aMessage = %d", aMessage );

    iMessageHandler.SendMessage( aMessage );

    NWLOGSTRING( KNWOBJECT, 

        "NW: CNWNetworkViagBaseEngine::SendMessage() End" );

    }

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

// CNWNetworkViagBaseEngine::WriteViagValues

// Writes Viag-values to networkinfo, shared data and system agent.

// (other items were commented in a header).

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

//

void CNWNetworkViagBaseEngine::WriteViagValues(

    const  TNWViagIndicatorType aIndicatorType,    //Indicates which zone it is

    const TInt& aZoneId )       // Viag text 

    {

    NWLOGSTRING3( KNWOBJECT, 

        "NW: CNWNetworkViagBaseEngine::WriteViagValues() \

        Begin, aIndicatorType = %d, aZoneId = %d", 

        aIndicatorType,aZoneId );

    TInt zoneType = ENWNone;

    // Intilise internal datastructure by defaul values (Not in any zone)

    iNWNetworkInfo.iViagIndicatorType = ENWViagIndicatorTypeNone;

    iNWNetworkInfo.iViagTextTag.Zero();

    // Get zone values

    switch( aIndicatorType )

        {

        // HomeZone

        case ENWViagIndicatorTypeHomeZone:

            if( !iActiveCall )

                {

                NWLOGSTRING2( KNWOBJECT, 

                    "NW: CNWNetworkViagBaseEngine::WriteViagValues() \

                    iZoneTags->Count = %d", iZoneTags->Count() );

                if ( aZoneId < iZoneTags->Count() )

                    {

                    TNWZoneTags zoneTags = iZoneTags->At( aZoneId );

                    iNWNetworkInfo.iViagIndicatorType = ENWViagIndicatorTypeHomeZone;

                    iNWNetworkInfo.iViagTextTag.Copy( zoneTags.iZoneTag ); //Array starts from 0.

                    }

                zoneType = ENWHomeZone;

                }

            break;

         //CityZone and the other known zones

         case ENWViagIndicatorTypeCityZone:

            if( !iActiveCall )

                {

                NWLOGSTRING2( KNWOBJECT, 

                    "NW: CNWNetworkViagBaseEngine::WriteViagValues() \

                    iZoneTags->Count = %d", iZoneTags->Count() );

                if ( aZoneId < iZoneTags->Count() )

                    {

                    TNWZoneTags zoneTags = iZoneTags->At( aZoneId );

                    iNWNetworkInfo.iViagIndicatorType = ENWViagIndicatorTypeCityZone;

                    iNWNetworkInfo.iViagTextTag.Copy( zoneTags.iZoneTag ); //Array starts from 0.

                    }

                zoneType = ENWCityZone;

                }

             break;

             // NoZone or UnknownZone

         case ENWViagIndicatorTypeNone:

         default:

             break;

         }

    // Update the PubSub key value

    TInt err = RProperty::Set( KPSUidNetworkInfo, KNWHomeZoneStatus, zoneType );

    if ( err != KErrNone )

        {

        NWLOGSTRING2( KNWERROR, 

            "NW: CNWNetworkViagEngine::WriteViagValues: RProperty\

            ::Set error: %d", err );

        }

    NWLOGSTRING2( KNWOBJECT, 

        "NW: CNWNetworkViagBaseEngine::WriteViagValues() Zone Text %S",

        &iNWNetworkInfo.iViagTextTag );