/*

* 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 <rmmcustomapi.h>

#include "CNWNetworkViagLcEngine.h"

#include "CNWNetworkViagBaseEngine.h"

#include "CNWNetworkViagTimer.h"

#include "NWPanic.pan"

#include "NWLogger.h"

//TEST

#include <f32file.h>

// CONSTANTS

const TInt KNWDigitMask = 0x30;

const TInt KNWRatMask = 0xC0;

const TInt KNWCodeMask = 0xF;

const TInt KTagLength( 12 );

const TInt KStopChar( 255 ); // 0xFF

const TUint KInvalid( 65535 ); // 0xFFFF 

const TInt KDualHandset( 1 );

const TInt KMaxVersion ( 255 );//  0xFF

const TInt KTagCount( 4 );

const TInt KTagOffset( 48 );

const TInt KCSTwo( 2 );

const TInt KCSNine( 9 );

const TInt KCSFour( 4 );

const TInt KCSThree( 3 );

const TInt KCSTen( 10 );

const TInt KCellAndLACLength( 5 );

const TInt KCmpLength( 4 );

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

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

// CNWNetworkViagLcEngine::CNWNetworkViagLcEngine

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

// might leave.

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

//

CNWNetworkViagLcEngine::CNWNetworkViagLcEngine(

    CNWNetworkViagBaseEngine& aBase,

    TNWInfo& aNetworkInfo,

    RMmCustomAPI& aCustomAPI,

    TNWInterInfo& aInterNetworkInfo)

      : iBase ( aBase ),

        iNWNetworkInfo( aNetworkInfo ),

        iCustomAPI( aCustomAPI ),

        iInterNetworkInfo( aInterNetworkInfo ),

        iLastSection ( EFalse ),

        iMatchFound ( EFalse ),

        iActivation( ETrue ),

        iCbActivation( EFalse ),

        iCurrentLcCache( NULL )

    {

    NWLOGSTRING( KNWOBJECT, 

        "NW: CNWNetworkViagLcEngine::CNWNetworkViagLcEngine() called." );

    }

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

// CNWNetworkViagLcEngine::ConstructL

// Symbian 2nd phase constructor can leave.

// --------------------KTagLength----------------------------------------------

//

void CNWNetworkViagLcEngine::ConstructL()

    {

    NWLOGSTRING( KNWOBJECT, "NW: CNWNetworkViagLcEngine::ConstructL() Begin" );

    iLcCacheOne = new ( ELeave ) TViagElementReocord;

    iLcCacheTwo = new ( ELeave ) TViagElementReocord;

    iLcCacheThree = new ( ELeave ) TViagElementReocord;

    iLcCacheFour = new ( ELeave ) TViagElementReocord;

    NWLOGSTRING( KNWOBJECT, "NW: CNWNetworkViagLcEngine::ConstructL() End" );

    }

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

// CNWNetworkViagLcEngine::NewL

// Two-phased constructor.

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

//

CNWNetworkViagLcEngine* CNWNetworkViagLcEngine::NewL(

                CNWNetworkViagBaseEngine& aBase,

                TNWInfo& aNetworkInfo, 

                RMmCustomAPI& aCustomAPI,

                TNWInterInfo& aInterNetworkInfo)

    {

    NWLOGSTRING( KNWOBJECT, 

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

    CNWNetworkViagLcEngine* self = new (ELeave) CNWNetworkViagLcEngine(

                aBase,

                aNetworkInfo,

                aCustomAPI,

                aInterNetworkInfo );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    NWLOGSTRING( KNWOBJECT, 

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

    return self;

    }

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

// CNWNetworkViagLcEngine::~CNWNetworkViagLcEngine

// Destructor

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

//

CNWNetworkViagLcEngine::~CNWNetworkViagLcEngine()

    {

    NWLOGSTRING( KNWOBJECT,

        "NW: CNWNetworkViagLcEngine::~CNWNetworkViagLcEngine() Begin" );

    if ( iLcCacheOne )

        {

        ResetLcCache( *iLcCacheOne ); // Reset old values.     

        delete iLcCacheOne;

        }

    if ( iLcCacheTwo )

        {

        ResetLcCache( *iLcCacheTwo );

        delete iLcCacheTwo;

        }

    if ( iLcCacheThree )

        {

        ResetLcCache( *iLcCacheThree );

        delete iLcCacheThree;

        }

    if ( iLcCacheFour )

        {

        ResetLcCache( *iLcCacheFour );

        delete iLcCacheFour;

        }

    NWLOGSTRING(KNWOBJECT, 

        "NW: CNWNetworkViagLcEngine::CNWNetworkViagLcEngine() End");

    }

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

// CNWNetworkViagLcEngine::AddInBufferAsTUint

// 

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

//

void CNWNetworkViagLcEngine::AddInBufferAsTUint( 

        TDes & aBuffer, const TUint aData )

    {

    NWLOGSTRING2( KNWOBJECT, 

        "NW: CNWNetworkViagLcEngine::AddInBufferAsTUint() Begin,\

        aData = %d.", aData );

    aBuffer.Append( TChar( aData ) );    

    NWLOGSTRING( KNWOBJECT, 

        "NW: CNWNetworkViagLcEngine::AddInBufferAsTUint() End." );

    }

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

// CNWNetworkViagLcEngine::ExtendTUintIntoBuffer

// 

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

//

void CNWNetworkViagLcEngine::ExtendTUintIntoBuffer( 

        TDes & aDestData, const TUint aData )

    {

    NWLOGSTRING( KNWOBJECT, 

        "NW: CNWNetworkViagLcEngine::ExtendTUintIntoBuffer() Begin." );

    aDestData.Zero();

    aDestData.AppendNum( aData );    

    NWLOGSTRING( KNWOBJECT, 

        "NW: CNWNetworkViagLcEngine::ExtendTUintIntoBuffer() End." );

    }

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

// CNWNetworkViagLcEngine::ParseResult

// Decides which parser is used. 

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

//

void CNWNetworkViagLcEngine::ParseResult( 

    TNWNetworkElementFile aElementFile, const TDesC8&  aResponse )

    {

    NWLOGSTRING2( KNWOBJECT, "NW: CNWNetworkViagLcEngine::ParseResult() Begin,\

        aElementFile = 0x%x", aElementFile );

    switch (aElementFile)

        {

        case EFileSettings:

            ParseSettings( aResponse );

            break;

        case EFileTags:        

            ParseTags( aResponse );

            break;

        case EFileSubscribedOne:

        case EFileSubscribedTwo:

        case EFileSubscribedThree:

        case EFileSubscribedFour:

            ParseSubscribed( aElementFile, aResponse  );

            break;

        case EFileHZ:

        case EFileUnknown:

            {

            NWLOGSTRING2( KNWOBJECT, 

                "NW: CNWNetworkViagSimReader::ReadSimFile NOT SUPPORTED VALUE \

                 %d", aElementFile );

            } 

        }

    NWLOGSTRING( KNWOBJECT, "NW: CNWNetworkViagLcEngine::ParseResult() End" );

    }

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

// CNWNetworkViagLcEngine::GetActivation

// Gets activation bits. 

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

//

void CNWNetworkViagLcEngine::GetActivation(

        TBool& aActivation, TBool& aCbActivation )

    {

    NWLOGSTRING3( KNWOBJECT, 

        "NW: CNWNetworkViagLcEngine::GetActivation() Begin,\

        aActivation = %d, aCbActivation = %d", 

        iActivation, iCbActivation );

    aActivation = iActivation;

    aCbActivation = iCbActivation;

    NWLOGSTRING( KNWOBJECT, 

        "NW: CNWNetworkViagLcEngine::ParseResult() End" );

    }

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

// CNWNetworkViagLcEngine::ParseSettings

// Parse setting value from response and update it if wanted. 

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

//

void CNWNetworkViagLcEngine::ParseSettings( const TDesC8& aResponse )

    {

    NWLOGSTRING( KNWOBJECT,

        "NW: CNWNetworkViagLcEngine::ParseSettings() Begin" );

    if ( aResponse.Length() >= 2 )

        {

        iActivation =  ( aResponse[0] & 0x01 );

        iCbActivation = STATIC_CAST( TBool,  ( aResponse[0] >> 1 ) & 0x01 );

        iVersion = static_cast<TUint8> (aResponse[1] );

        NWLOGSTRING2( KNWOBJECT, 

            "NW: CNWNetworkViagLcEngine::ParseSettings Version = %d", 

            iVersion );

        if ( iActivation ) // The general activation must be "activation"

            {

            if ( ( iVersion + KDualHandset ) > KMaxVersion ) // The update version must not be over 0xFF if so the 

                {

                iVersion = 0x00; 

                }

            else

                {

                iVersion =  static_cast<TUint8> ( iVersion + KDualHandset  );

                NWLOGSTRING2( KNWOBJECT, 

                    "NW: CNWNetworkViagLcEngine::UpdateVersion Version = %d", 

                    iVersion );

                }

            UpdateVersion();

            }

        }

    NWLOGSTRING( KNWOBJECT, 

        "NW: CNWNetworkViagLcEngine::ParseSettings() End" );

    }

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

// CNWNetworkViagLcEngine::UpdateVersion

// Updates version number to SIM

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

//

void CNWNetworkViagLcEngine::UpdateVersion( )

    {

    NWLOGSTRING( KNWOBJECT,

        "NW: CNWNetworkViagLcEngine::UpdateVersion() Begin" );

    TInt errorCode( KErrNone );

    RMmCustomAPI::TViagUHZIUESettings hzSettings;

    if ( iActivation )

        {

        hzSettings.iSettings = 1;

        if ( iCbActivation )

            {

            hzSettings.iSettings = 3;

            }

        hzSettings.iVersion = iVersion;

        NWLOGSTRING2( KNWOBJECT, 

            "NW: CNWNetworkViagLcEngine::UpdateVersion iSettings = %d", 

            hzSettings.iSettings );

        NWLOGSTRING2( KNWOBJECT, 

            "NW: CNWNetworkViagLcEngine::UpdateVersion Version = %d", 

            hzSettings.iVersion );

        errorCode = iCustomAPI.WriteViagHomeZoneUHZIUESettings( hzSettings ); 

        if ( errorCode != KErrNone )

            {

            NWLOGSTRING2( KNWOBJECT,

                "NW: CNWNetworkViagLcEngine::UpdateVersion Error %d", 

                errorCode );

            }

        }

    else

        {

        NWLOGSTRING( KNWOBJECT,

            "NW: CNWNetworkViagLcEngine::UpdateVersion \

            General activation is OFF" );

        }

    NWLOGSTRING( KNWOBJECT,

        "NW: CNWNetworkViagLcEngine::UpdateVersion() End" );

    }

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

// CNWNetworkViagLcEngine::ParseTags

// Parses zone tags from response and writes them to iZoneTags struct. 

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

//

void CNWNetworkViagLcEngine::ParseTags( const TDesC8&  aResponse )

    {

    NWLOGSTRING2( KNWOBJECT, 

        "NW: CNWNetworkViagLcEngine::ParseTags() Begin,\

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

    TLex8 parse( aResponse );

    TInt zoneCount( 1 );

    TLexMark8 start;

    parse.Inc( KTagOffset ); // first 48 bits are ignored. 

    while ( zoneCount <= KTagCount ) // 4 zones, 

        {

        // 48.....96    Tag file legth is 96 bytes

        if ( ( KTagLength * zoneCount   ) <= aResponse.Length() )

            {

            parse.Mark( start );

            parse.Inc( KTagLength ); // // First tag

            TPtrC8 tag = parse.MarkedToken( start );

            TBuf<KTagLength> zoneText;

            TInt length = tag.Locate( KStopChar );

            TPtrC8 tempTag;

            // Check that there does'n come overflow

            if( length > KTagLength )

                {

                length = KTagLength;

                }

            if ( length > 0 )

                {

                tempTag.Set( tag.Left( length ) );

                iBase.DefaultAlphabetDecode( tempTag, zoneText );

                }

            else if ( length == KErrNotFound )

                {

                tempTag.Set( tag.Left( KTagLength ) );

                iBase.DefaultAlphabetDecode( tempTag, zoneText );

                } 

            else

                {

                zoneText.Copy( KNullDesC );

                }

            iBase.SetZoneTag( zoneCount+3, zoneText ); // First 4 tags comes from HZ file.

            }

        zoneCount++;    

        }

    NWLOGSTRING2( KNWOBJECT, "NW: CNWNetworkViagLcEngine::ParseTags(),\

        zoneCount = %d ", zoneCount ); 

    NWLOGSTRING( KNWOBJECT, "NW: CNWNetworkViagLcEngine::ParseTags() End" );

    }

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

// CNWNetworkViagLcEngine::ParseSubscribed

// Checks if current LAC file contains any subscribed cells. If at least one subscribed cell is found 

// parsefield method is called. 

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

//

void CNWNetworkViagLcEngine::ParseSubscribed( 

        TNWNetworkElementFile aElementFile, 

        const TDesC8&  aResponse )

    {

    NWLOGSTRING3( KNWOBJECT, 

        "NW: CNWNetworkViagLcEngine::ParseSubscribed() Begin,\

        aElementFile = 0x%x, length(aResponse) = %d",

        aElementFile, aResponse.Length());

    switch ( aElementFile )

        {

        case EFileSubscribedOne:

            { 

            iCurrentLcCache  =  iLcCacheOne;

            iLastSection = EFalse;

            break;    

            }

        case EFileSubscribedTwo:

            {

            iCurrentLcCache  =  iLcCacheTwo;

            iLastSection = EFalse;

            break;

            }

        case EFileSubscribedThree:

            {

            iCurrentLcCache  =  iLcCacheThree;    

            iLastSection = EFalse;

            break;

            }

        case EFileSubscribedFour:

            {

            iCurrentLcCache  =  iLcCacheFour;    

            iLastSection = EFalse;

            break;

            }

        case EFileHZ:

        case EFileTags:

        case EFileSettings:

        case EFileUnknown:

        default:

            {

            NWLOGSTRING( KNWOBJECT, 

                "NW: CNWNetworkViagLcEngine::ParseSubscribed() NOT SUPPORTED \

                element file" );

            break;

            }

        }

    ResetLcCache( *iCurrentLcCache );

    if ( aResponse.Length() >= 2 )

        {

        TLex8 parse ( aResponse );

        //************************************************    

        //** Network Coding is 3 bytes length 

        //************************************************

        iCurrentLcCache->iRatType = static_cast<TNWRatType> ( 

                aResponse[0] & KNWRatMask ) ; 

        if ( (aResponse[0] == 0xFF) && (aResponse[1] ==0xFF) && 

                (aResponse[2] ==0xFF))

            {

             // Lac file not contain any subscribed cells.

            NWLOGSTRING( KNWOBJECT, 

                "NW: CNWNetworkViagLcEngine::ParseSubscribed(),\

                ac file not contain any subscribed cells" );

             iCurrentLcCache->iCellSubscribed = EFalse;

            return;

            }

        iCurrentLcCache->iCellSubscribed = ETrue;

        TUint temp = ( aResponse[0] & KNWCodeMask) ;        

        temp =   temp  << 16  | aResponse[1] << 8  | aResponse[2] ;

        TBuf<6> netdes;

        netdes.Num(temp);    

        iCurrentLcCache->iMCC = netdes.Left( 3 );  

        NWLOGSTRING2( KNWOBJECT, 

            "NW: CNWNetworkViagLcEngine::ParseSubscribed() iMCC = %S", 

            &iCurrentLcCache->iMCC );

        if ( (aResponse[0] & KNWDigitMask) == 0x00 )

            {

            NWLOGSTRING( KNWOBJECT, 

               "NW: CNWNetworkViagLcEngine::ParseSubscribed(),\

               (aResponse[0] & KNWDigitMask) == 0x00 " );

            iCurrentLcCache->iMNC = netdes.Mid( 3,2 );  

            }

        else

            {

            iCurrentLcCache->iMNC = netdes.Right( 3 );      

            }

        NWLOGSTRING2( KNWOBJECT, 

            "NW: CNWNetworkViagLcEngine::ParseSubscribed() iMNC = %S", 

            &iCurrentLcCache->iMNC );

        parse.Inc( 3 ); //  Skip the network coding out because above used hard coded values.

        //*******************************************************

        //** Start field parsing.            

        //*******************************************************

        iCurrentLcCache->iCellSubscribed = ParseField( parse );

        }

    NWLOGSTRING( KNWOBJECT, 

        "NW: CNWNetworkViagLcEngine::ParseSubscribed() End" );

    }

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

// CNWNetworkViagLcEngine::ParseField

// Parses fields from given string to iField 

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

//

TBool CNWNetworkViagLcEngine::ParseField( TLex8& aParse )

    {

    NWLOGSTRING( KNWOBJECT, "NW: CNWNetworkViagLcEngine::ParseField() Begin" );

    // Parse so long that last section 

    while ( !iLastSection ) // Continue so long that last section is ongoing.

        {

        TBool invalid =  ParseSection( aParse ); // Parse next section...

        if ( invalid )

            {

            iLastSection = ETrue;