/*

* 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 CPENetworkViagEngine

*                 class member functions.

*

*/

// INCLUDE FILES

#include    "CNWNetworkViagCbEngine.h"

#include    "CNWNetworkViagBaseEngine.h"

#include    "CNWNetworkViagTimer.h"

#include    "NWPanic.pan"

#include    "NWLogger.h"

// CONSTANTS

const TUint KNWzero = 0;

const TUint KNWCityZone = 3;

const TInt  KHZCBSMessageDataMaxLength = 2 * KNWViagHzCoordinateLength; // x-coordinate and y-coordinate i.e. '111111222222'

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

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

// CNWNetworkViagCbEngine::CNWNetworkViagCbEngine

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

// might leave.

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

//

CNWNetworkViagCbEngine::CNWNetworkViagCbEngine(

    CNWNetworkViagBaseEngine& aBase,

    TNWInfo& aNetworkInfo,

    RMmCustomAPI& aCustomAPI,

    TNWInterInfo& aInterNetworkInfo,

    CNWGsmNetworkCellReselectionHandler& aCellReselectionHandler )

      : 

        iBase ( aBase ),

        iNWNetworkInfo( aNetworkInfo ),

        iCustomAPI( aCustomAPI ),

        iInterNetworkInfo( aInterNetworkInfo ),

        iCellReselectionHandler( aCellReselectionHandler )

    {

    iCBSState = EListeningNone;

    NWLOGSTRING(KNWOBJECT, 

        "NW: CNWNetworkViagCbEngine::CNWNetworkViagCbEngine complete");

    }

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

// CNWNetworkViagCbEngine::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CNWNetworkViagCbEngine::ConstructL()

    {

    NWLOGSTRING(KNWOBJECT, 

           "NW: CNWNetworkViagCbEngine::CNWNetworkViagCbEngine Begin");

    iTimer = CNWNetworkViagTimer::NewL();

    iElements = new ( ELeave ) RMmCustomAPI::TViagElements( 1 ); //create array

    iElements->ResizeL( RMmCustomAPI::KViagElementCount );

    iActiveZoneArray = new ( ELeave ) CViagZoneArray( 1 ); //create array

    iActiveZoneArray->ResizeL( RMmCustomAPI::KViagElementCount );

    iCacheHandler = CNWNetworkHZCbCacheHandler::NewL( iCustomAPI );

    NWLOGSTRING(KNWOBJECT, 

           "NW: CNWNetworkViagCbEngine::CNWNetworkViagCbEngine End");

    }

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

// CNWNetworkViagCbEngine::NewL

// Two-phased constructor.

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

//

CNWNetworkViagCbEngine* CNWNetworkViagCbEngine::NewL(

                CNWNetworkViagBaseEngine& aBase,

                TNWInfo& aNetworkInfo, 

                RMmCustomAPI& aCustomAPI,

                TNWInterInfo& aInterNetworkInfo,

                CNWGsmNetworkCellReselectionHandler& aCellReselectionHandler )

    {

    NWLOGSTRING(KNWOBJECT, 

           "NW: CNWNetworkViagCbEngine::CNWNetworkViagCbEngine Begin");

    CNWNetworkViagCbEngine* self = new (ELeave) CNWNetworkViagCbEngine(

                aBase,

                aNetworkInfo,

                aCustomAPI,

                aInterNetworkInfo,

                aCellReselectionHandler );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    NWLOGSTRING(KNWOBJECT, 

           "NW: CNWNetworkViagCbEngine::CNWNetworkViagCbEngine End");

    return self;

    }

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

// CNWNetworkViagEngine::~CNWNetworkViagCbEngine

// Destructor

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

//

CNWNetworkViagCbEngine::~CNWNetworkViagCbEngine()

    {

    NWLOGSTRING(KNWOBJECT, 

        "NW: CNWNetworkViagCbEngine::~CNWNetworkViagCbEngine Begin");

    if ( iMcn )

        {

        if( iCBSState == EListeningViag )

            {

            NWLOGSTRING( KNWINT, "NW: CNWnetworkviagengine > imcn.unregister" );

            iMcn->Unregister( this );

            }

        iMcn = NULL; // CNWGsmNetworkCellReselectionHandler has ownership. 

        }

    delete iActiveZoneArray;  //delete array

    delete iElements; //delete array

    delete iTimer; //delete timer

    delete iCacheHandler;

    NWLOGSTRING(KNWOBJECT, 

        "NW: CNWNetworkViagCbEngine::~CNWNetworkViagCbEngine() End");

    }

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

// CNWNetworkViagEngine::CellInfoChanged

// Gets called when a message of a subscribed topic is received from the network.

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

//

TInt CNWNetworkViagCbEngine::CellInfoChanged(

    const TCbsMcnMessage& aMcnMessage ) //MCN message received from the network. 

    {

    NWLOGSTRING2( KNWINT, 

        "NW: CNWNetworkViagEngine::CellInfoChanged, topic = %d", 

        aMcnMessage.iTopicNumber );

    //HZI message, check that we really are listening it

    if( aMcnMessage.iTopicNumber == KNWHomeZoneMsgId && 

            iCBSState==EListeningViag )

        {

        TInt error = HandleCBSMessages( aMcnMessage );

        if(  error != KErrNone )

            {

            NWLOGSTRING2( KNWERROR, 

                "NW: CNWNetworkViagEngine::CellInfoChanged, HandleCBSMessages \

                error, error code = %d", error );

            }

        else

            {

            iBase.SendMessage( 

                 MNWMessageObserver::ENWMessageCurrentHomeZoneMessage );

            }

        }

    NWLOGSTRING( KNWINT, 

        "NW: CNWNetworkViagEngine::CellInfoChanged() End" );

    //This is called by MCN client API, so we return always KErrNone

    return KErrNone;

    }

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

// CNWNetworkViagEngine::StopCbAlgo

// Stops CBS activities

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

//

void CNWNetworkViagCbEngine::StopCbAlgo()

    {

    NWLOGSTRING( KNWINT, "NW: CNWNetworkViagCbEngine::StopCbAlgo() Begin" );

    iTimer->Cancel();

    iState=EIdle;

    if( iCBSState == EListeningViag )

        {

        if ( iMcn )

            {

            NWLOGSTRING( KNWINT, "NW: CNWNetworkViagEngine::StopCbAlgo: iMcn.Unregister" );

            iMcn->Unregister( this );

            }

        iCBSState=EListeningNone;

        }

    NWLOGSTRING( KNWINT, "NW: CNWNetworkViagCbEngine::StopCbAlgo() End" );

    }

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

// CNWNetworkViagCbEngine::CellReselection

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

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

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

//

void CNWNetworkViagCbEngine::CellReselection()

    {

    NWLOGSTRING( KNWINT, 

            "NW: CNWNetworkViagCbEngine::CellReselection() Begin" );

    TUint cellId = iInterNetworkInfo.iCellId;

    iCellInfo.iCellId = static_cast<TUint16>( cellId );

    iCellInfo.iLac = static_cast<TUint16>( iInterNetworkInfo.iLac );

    // StartIndicatorhandling must be called even if cache reading fails.

    if ( iCacheHandler->InitialisingStatus() == ECBSHZCacheReader_Ready )

        {

        TRAPD( err, StartIndicatorHandlingL( EFalse ) )

        if( err!= KErrNone )

            {

            __ASSERT_DEBUG( EFalse, Panic( ENWPanicNotCompleted ) );

            }

        }

    else

        {

        NWLOGSTRING( KNWINT, 

            "NW: CNWNetworkViagCbEngine::CellReselection Cache Reading is Ongoing, Do nothing " );

        }

    NWLOGSTRING( KNWINT, 

            "NW: CNWNetworkViagCbEngine::CellReselection() End" );

    }

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

// CNWNetworkViagCbEngine::IsActiveZone

// Checks if there are active Viag Zones

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

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

//

void CNWNetworkViagCbEngine::IsActiveZone( )

    {

    NWLOGSTRING( KNWINT, 

                "NW: CNWNetworkViagCbEngine::CellReselection() Begin" );

    //Check that mobile is camping on the Viag network.

    TInt mcc = KNWzero;

    if ( TLex( iNWNetworkInfo.iCountryCode ).Val( mcc ) != KErrNone )

        {

        //No error handling convention to use with this error

        NWLOGSTRING( KNWERROR, "NW: ERROR: CNWNetworkViagCbEngine::ISACTIVEZONE ! TLEX OPERATION FAILED 1");

        }

    TInt mnc = KNWzero;

    if ( TLex( iNWNetworkInfo.iNetworkId ).Val( mnc ) != KErrNone )

        {

        //No error handling convention to use with this error

        NWLOGSTRING( KNWERROR, "NW: ERROR: CNWNetworkViagCbEngine::ISACTIVEZONE ! TLEX OPERATION FAILED 2");

        }

    NWLOGSTRING3( KNWINT, "NW: CNWNetworkViagCbEngine::CellReselection(), \

            mcc = %d, mnc = %d ", mcc, mnc );

    if( mcc == KNWViagMcc && mnc == KNWViagMnc )

        {

        TBool home( EFalse ); 

        TBool city( EFalse );

        TInt count = iActiveZoneArray->Count();

        NWLOGSTRING2( KNWINT, "NW: CNWNetworkViagCbEngine::CellReselection(), \

                   number of active zones = %d", count );

        for ( TInt i=count-1; i>=0; i-- )

            {

            TViagZoneInfo info = iActiveZoneArray->At(i);

            if ( info.iActiveFlag == RMmCustomAPI::EHomeZone )

                {

                home=ETrue;

                //error is ignored, since it will always succeed.

                }

            else if ( info.iActiveFlag == RMmCustomAPI::ECityZone )

                {

                city=ETrue;

                //error code is ignored

                }

            }

        if(home && city)

            iIsActiveZones=EBothActive;

        else if(home)

            iIsActiveZones=EHomeActive;

        else if(city)

            iIsActiveZones=ECityActive;

        else

            iIsActiveZones=ENoneActive;

        }

    else    

        iIsActiveZones=ENoneActive;

    NWLOGSTRING2( KNWINT, "NW: CNWNetworkViagCbEngine::IsActiveZone: Active zones(0 none, 1 hz, 2 cz, 3 both): %d", iIsActiveZones );

    }

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

// CNWNetworkViagCbEngine::UpdateViagHzParams

// Updates Viag HomeZone parameters from SIM.

// KErrNone if everything goes allright.

// Some error value if CustomAPI call or Append fails

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

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

//

TInt CNWNetworkViagCbEngine::UpdateViagHzParams()

    {

    NWLOGSTRING( KNWINT, 

                    "NW: CNWNetworkViagCbEngine::UpdateViagHzParams() Begin" );

    //Empty elements without free memory

    TInt count = iElements->Count();

    TInt i;

    NWLOGSTRING2( KNWINT, "NW: CNWNetworkViagCbEngine::UpdateViagHzParams(), \

            iElements->Count() = %d", count );

    for ( i = count-1; i>=0; i-- )

        {

        iElements->Delete( i );

        }

    //For TSY requires this to be the array's size

    TRAPD( err, iElements->ResizeL( RMmCustomAPI::KViagElementCount ) )

        if( err != KErrNone )

            {

            //error handling

            NWLOGSTRING2( KNWINT, "NW: CNWNetworkViagCbEngine::\

                UpdateViagHzParams(), elements array resize error: %d", err );

            return err;

            }

    NWLOGSTRING( KNWREQOUT, 

        "NW: CNWNetworkViagCbEngine::UpdateViagHzParams: \

        ReadViagHomeZoneParams()" );

    TInt error = iCustomAPI.ReadViagHomeZoneParams( iParams, *iElements );

    if( error == KErrNone )

        {

        NWLOGSTRING( KNWINT, 

            "NW: CNWNetworkViagCbEngine::UpdateViagHzParams: params updated" );

        //Empty zoneArray without free memory

        count = iActiveZoneArray->Count();

        NWLOGSTRING2( KNWINT, "NW: CNWNetworkViagCbEngine::\

             UpdateViagHzParams(), number of active zones: %d", count );

        for ( i = count-1; i>=0; i-- )

            {

            iActiveZoneArray->Delete( i );

            }

        count = iElements->Count();

        for ( i = KNWzero; i < count; i++ )

            {

            RMmCustomAPI::TViagElement& element = iElements->At( i );

            TViagZoneInfo info;

            info.iX = element.iCoordinates.iX;

            info.iY = element.iCoordinates.iY;

            info.iR2 = element.iCoordinates.iR2;

            info.iZoneId = element.iCoordinates.iZoneId;

            info.iName.Copy( element.iName );

            iBase.SetZoneTag( info.iZoneId-1, info.iName );

            NWLOGSTRING3( KNWINT, 

                "NW: CNWNetworkViagCbEngine::UpdateViagHzParams: \

                Zone Id: %d, element name: %S ", 

                info.iZoneId, &info.iName );

            NWLOGSTRING4( KNWINT, "ViagEngine::UpdateViagHzParams: \

                iX = %d, iY = %d, iR2 = %d", 

                info.iX, info.iY, info.iR2);

            switch( element.iActiveFlag )

                {

                case RMmCustomAPI::ENotActive:

                    info.iActiveFlag = RMmCustomAPI::ENotActive;

                    NWLOGSTRING( KNWINT, 

                        "NW: CNWNetworkViagCbEngine::UpdateViagHzParams \

                        ! ENotActive" );

                    break;

                case RMmCustomAPI::EHomeZone:

                    info.iActiveFlag = RMmCustomAPI::EHomeZone;

                    NWLOGSTRING( KNWINT, 

                        "NW: CNWNetworkViagCbEngine::UpdateViagHzParams !\

                        EHomeZone active" );

                    break;

                case RMmCustomAPI::ECityZone:

                    info.iActiveFlag = RMmCustomAPI::ECityZone;

                    NWLOGSTRING( KNWINT, 

                        "NW: CNWNetworkViagCbEngine::UpdateViagHzParams ! \

                        ECityZone active " );

                    break;

                default:

                    break;

                }

            // If zone is active, add it into iActiveZoneArray

            if ( element.iActiveFlag != RMmCustomAPI::ENotActive )

                {

                TRAPD( err, iActiveZoneArray->AppendL( info ) )//lint !e578

                if( err != KErrNone )

                    {

                    //error handling

                    NWLOGSTRING2( KNWERROR, 

                        "NW: CNWNetworkViagCbEngine::UpdateViagHzParams(),\

                        error code = %d", err );

                    return err;

                    }

                }

            }

        NWLOGSTRING2( KNWINT, "NW: CNWNetworkViagCbEngine::\

             UpdateViagHzParams(), after loop running variable i = %d", i );

        }

    NWLOGSTRING2( KNWINT, 

        "NW: CNWNetworkViagCbEngine::UpdateViagHzParams: returns %d", error );

    return error;

}

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

// CNWNetworkViagCbEngine::RegisterToCBS

// Registers to listening CBS messages

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

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

//

void CNWNetworkViagCbEngine::RegisterToCBSL(

    TUint16 aTopic )

    {

    NWLOGSTRING2( KNWINT, "NW: CNWNetworkViagCbEngine::RegisterToCBSL() Begin,\

        aTopic = %d ", aTopic );

    if( !iMcn )

        {

        iMcn = iCellReselectionHandler.GetMcnPtr();

        }

    if( iMcn )

        {

        // Specify topics with CMcnTopicArray.

        CMcnTopicArray* topics = CMcnTopicArray::NewL();

        CleanupStack::PushL( topics );

        topics->AddCbTopicL( aTopic );      // MCN Info (cell info)

        // Register. Parameter observer is an instance of CCbsMcnObserver.

        NWLOGSTRING( KNWINT, "NW: CNWNetworkViagEngine::RegisterToCBSL > imcn.registerL()" );

        iMcn->RegisterL( this, *topics );

        iCBSState = EListeningViag;

        NWLOGSTRING( KNWINT, 

            "NW: CNWNetworkViagEngine::RegisterToCBSL ! Registered to Viag messages" );

        // Start CBS message waiting timer

        iTimer->Cancel();

        iTimer->After( KViagTimerSixtySeconds, this );

        iState = ECbsSixtySecondsWaiting;

        NWLOGSTRING( KNWINT, "NW: CNWNetworkViagCbEngine::RegisterToCBSL 60s timer started" );

        CleanupStack::PopAndDestroy( topics );

        }

    NWLOGSTRING( KNWINT, 

        "NW: CNWNetworkViagCbEngine::RegisterToCBSL ! Registered to Viag \

        messages" );

    }   

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

// CNWNetworkViagCbEngine::StartIndicatorHandlingL

// Checks and indicates user if current zone is City/HomeZone.

// This method reads params from SIM card and checks if current zone is active 

// zone and if it is in SIM cache. It also starts 60 second timer to listen for 

// CBS messages.

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

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

//

void CNWNetworkViagCbEngine::StartIndicatorHandlingL( TBool aRefreshOccureed )

    {

    NWLOGSTRING( KNWINT, 

        "NW: CNWNetworkViagCbEngine::StartIndicatorHandlingL Begin" );

    ResetIndicatorValues();

    IsActiveZone();

    NWLOGSTRING3( KNWINT, "NW: CNWNetworkViagCbEngine::StartIndicatorHandlingL(),\

            iIsActiveZones = %d, iInterNetworkInfo.iCellId = %d", iIsActiveZones,

            iInterNetworkInfo.iCellId );

    // Is there any active zones?

    if( iIsActiveZones && iInterNetworkInfo.iCellId != 0 )

        {

        TInt cache = SearchHomeZoneCaches( iCellInfo, iActiveZoneArray );

        if( cache >= EHZ_HomeZoneCache1 )

            {

            // Found from cache. Update values to UI.

            if( cache == EHZ_HomeZoneCache1 ||

                cache == EHZ_HomeZoneCache2 || 

                cache == EHZ_HomeZoneCache3 )

                {

                NWLOGSTRING( KNWINT, 

                    "NW: CNWNetworkViagCbEngine::StartIndicatorHandlingL ! \

                    Calling writeviagvalues" );  

                iBase.WriteViagValues( ENWViagIndicatorTypeHomeZone,

                                       cache - 1 );

                }

            else if( cache == EHZ_CityZoneCache )

                {

                NWLOGSTRING( KNWINT, 

                    "NW: CNWNetworkViagCbEngine::StartIndicatorHandlingL ! \

                    Calling writeviagvalues" );

                iBase.WriteViagValues( ENWViagIndicatorTypeCityZone,

                                     KNWCityZone );  // 3 is cityzone 

                }

            }            

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

       // No cell found from cache 

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

        else