/*

* Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:

*

*/

// INCLUDE FILES

#include "cmmnetmesshandler.h"

#include "cmmnetoperatornamehandler.h"

#include "toperatornames.h"

#include "cmmphonetsender.h"

#include "cmmstaticutility.h"

#include "cmmmessagerouter.h"

#include "cmmpacketmesshandlercontextlist.h"

#include "cmmpacketservicemesshandler.h"

#include "cmmcustommesshandler.h"

#include "tsylogger.h" // Logging

#include "cmmuiccmesshandler.h"

#include <ctsy/serviceapi/mmgsmwcdmautils.h> // For mapping utilities

#include <ctsy/pluginapi/cmmdatapackage.h>

#include <ctsy/serviceapi/mmtsy_defaults.h> // KMmTsyNITZCaps needed

#include <etelmm.h>

#include <ctsy/serviceapi/gsmerror.h>

#include <net_modemisi.h>

#include <infoisi.h>

#include <tisi.h>

#include <gpdsisi.h>

//#include <permisi.h> To be done in CPS

#include <uiccisi.h>

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmmnetmesshandlerTraces.h"

#endif

// EXTERNAL DATA STRUCTURES

    //None

// EXTERNAL FUNCTION PROTOTYPES

    //None

// CONSTANTS

// Hard-coded transaction id for ISA messages

const TUint8 KNetTransId = 4;

// const TUint8 KNbImsSubBlocks = 3; Compiler warning removal

// Default value for registered in another network in GSM

const TUint8 KDefaultRegInAnotherNwGsm = 0;

// Operator code for (MCC MNC): 262 07

_LIT8( KO2NetworkId, "\x62\xF2\x70" );

// HPLMN read from SIM (MCC MNC): 262 08

_LIT8( KO2Hplmn, "\x62\xF2\x80" );

#ifdef OST_TRACE_COMPILER_IN_USE

const TUint8 KBufferForOSTTracing = 100;

#endif

#ifdef TF_LOGGING_ENABLED

const TUint8 KBufferForTFLogging = 130;

#endif

// MACROS

    //None

// LOCAL CONSTANTS AND MACROS

    //None

// MODULE DATA STRUCTURES

// limit values for mapping RSSI percentage to number of signal strength bars

const TUint8 netRssiLimitsTable[KMaxSignalStrengthBars] =

     {

     1, 16, 33, 49, 66, 83, 99

     };

// LOCAL FUNCTION PROTOTYPES

    //None

// FORWARD DECLARATIONS

    //None

// ============================= LOCAL FUNCTIONS ===============================

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

// TFLOG_PRINT_ISIMESSAGE

// local function for printing queued Net message contents

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

//

#if defined (TF_LOGGING_ENABLED) || defined (OST_TRACE_COMPILER_IN_USE)

static void TFLOG_PRINT_ISIMESSAGE( const TDesC8& aBuf )

    {

    _LIT( KTraceSpace,           " " );

    // Get the length of the ISI message.

    TInt length = aBuf.Length();

#ifdef TF_LOGGING_ENABLED

    TBuf<KBufferForTFLogging> msg;

    _LIT( KTraceQueuedMessage,  "TSY:Queued NET message:  [ " );

    _LIT( KTraceBracketClose,    "]" );

    msg.Append( KTraceQueuedMessage );

    if ( 250 < length )

        {

        // Print only 250 first bytes.

        length = 250;

        }

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

        {

        msg.AppendNumFixedWidthUC( aBuf[i], EHex, 2 );

        msg.Append( KTraceSpace );

        if ( KLogSizeOfBuffer-10 < msg.Length() )

            {

            if ( i == ( length - 1 ) )

                {

                // Last number, append "]" character.

                msg.Append( KTraceBracketClose );

                }

            TFLOGTEXT( msg );

            msg.SetLength( 0 );

            }

        }

    if ( 0 < msg.Length() )

        {

        // Buffer contains data. Print also last line.

        msg.Append( KTraceBracketClose );

        TFLOGTEXT( msg );

        }

#endif // TF_LOGGING_ENABLED

    // Ost tracing.

#ifdef OST_TRACE_COMPILER_IN_USE

    TBuf8<KBufferForOSTTracing> trace_msg;

    TUint8 counter = 1;

    TBool firstTime = ETrue;

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

        {

        trace_msg.AppendNumFixedWidthUC( aBuf[i], EHex, 2 );

        trace_msg.Append( KTraceSpace );

        if ( ( counter > 24 ) ||     // 25 bytes / line.

            ( ( i + 1 ) == length ) ) // All bytes collected.

            {

            if ( ( firstTime ) &&

                ( ( i + 1 ) == length ) ) // All bytes collected and traced.

                {

                firstTime = EFalse;

OstTraceExt1( TRACE_NORMAL, DUP6__TFLOG_PRINT_ISIMESSAGE, "TSY:Queued NET message: [ %s]", trace_msg );

                trace_msg.SetLength( 0 );

                }

            else if ( firstTime ) // 1st line of the trace.

                {

                firstTime = EFalse;

OstTraceExt1( TRACE_NORMAL, DUP7__TFLOG_PRINT_ISIMESSAGE, "TSY:Queued NET message: [ %s", trace_msg );

                trace_msg.SetLength( 0 );

                }

            else if ( ( i + 1 ) == length ) // The last line.

                {

OstTraceExt1( TRACE_NORMAL, DUP8__TFLOG_PRINT_ISIMESSAGE, "TSY:Queued NET message:   %s]", trace_msg );

                trace_msg.SetLength( 0 );

                }

            else // just print bytes.

                {

OstTraceExt1( TRACE_NORMAL, DUP9__TFLOG_PRINT_ISIMESSAGE, "TSY:Queued NET message:   %s", trace_msg );

                trace_msg.SetLength( 0 );

                }

            counter = 0;

            }

        counter++;

        }

#endif // OST_TRACE_COMPILER_IN_USE

    }

#else // TF_LOGGING_ENABLED || OST_TRACE_COMPILER_IN_USE

#define TFLOG_PRINT_ISIMESSAGE(x)

#endif // TF_LOGGING_ENABLED || OST_TRACE_COMPILER_IN_USE

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

// CalculateNetworkInformationSbStartOffset

// Calculates starting subblocks offset for NET_MODEM_REG_STATUS_IND,

// NET_SET_RESP and NET_MODEM_REG_STATUS_GET_RESP

// @param aIsiMessage ISI-message to process

// @param aSbStartOffset subblock start offset to initialize

// @return TInt KErrNone or KErrNotSupported

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

//

static TInt CalculateNetworkInformationSbStartOffset(

    const TIsiReceiveC& aIsiMessage,

    TUint& aSbStartOffset

    )

    {

    TInt ret( KErrNone );

    TFLOGSTRING("TSY: CalculateNetworkInformationSbStartOffset");

    OstTrace0( TRACE_NORMAL, _CALCULATENETWORKINFORMATIONSBSTARTOFFSET, "CalculateNetworkInformationSbStartOffset" );

    TUint8 messageId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID );

    if ( NET_MODEM_REG_STATUS_IND == messageId )

        {

        TFLOGSTRING("TSY: CalculateNetworkInformationSbStartOffset; NET_REG_STATUS_IND");

        OstTrace0( TRACE_NORMAL, DUP1__CALCULATENETWORKINFORMATIONSBSTARTOFFSET, "CalculateNetworkInformationSbStartOffset; NET_REG_STATUS_IND" );

        aSbStartOffset = SIZE_NET_MODEM_REG_STATUS_IND;

        }

    else if ( NET_MODEM_REG_STATUS_GET_RESP == messageId )

        {

        TFLOGSTRING("TSY: CalculateNetworkInformationSbStartOffset; NET_REG_STATUS_GET_RESP");

        OstTrace0( TRACE_NORMAL, DUP2__CALCULATENETWORKINFORMATIONSBSTARTOFFSET, "CalculateNetworkInformationSbStartOffset; NET_REG_STATUS_GET_RESP" );

        aSbStartOffset = SIZE_NET_MODEM_REG_STATUS_GET_RESP;

        }

    else if ( NET_SET_RESP == messageId )

        {

        TFLOGSTRING("TSY: CalculateNetworkInformationSbStartOffset; NET_SET_RESP");

        OstTrace0( TRACE_NORMAL, DUP3__CALCULATENETWORKINFORMATIONSBSTARTOFFSET, "CalculateNetworkInformationSbStartOffset; NET_SET_RESP" );

        aSbStartOffset = SIZE_NET_SET_RESP;

        }

    else

        {

        TFLOGSTRING2("TSY: CalculateNetworkInformationSbStartOffset;unknown messageId=%x", messageId);

        OstTrace1( TRACE_NORMAL, DUP4__CALCULATENETWORKINFORMATIONSBSTARTOFFSET, "CalculateNetworkInformationSbStartOffset;unknown messageId=%x", messageId );

        ret = KErrNotSupported;

        }

    return ret;

    }

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

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

// CMmNetMessHandler::CMmNetMessHandler

// C++ default constructor

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

//

CMmNetMessHandler::CMmNetMessHandler()

    {

TFLOGSTRING("TSY: CMmNetMessHandler::CMmNetMessHandler() - Start");

OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_CMMNETMESSHANDLER, "CMmNetMessHandler::CMmNetMessHandler" );

    }

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

// CMmNetMessHandler::NewL

// Two-phased constructor.

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

//

CMmNetMessHandler* CMmNetMessHandler::NewL

        (

        CMmPhoNetSender* aPhoNetSender, // Pointer to the phonet sender

        CMmPhoNetReceiver* aPhoNetReceiver, // Pointer to the phonet receiver

        CMmMessageRouter* aMessageRouter, // Pointer to the message router

        CMmUiccMessHandler* aUiccMessHandler

        )

    {

TFLOGSTRING("TSY: CMmNetMessHandler::NewL");

OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_NEWL, "CMmNetMessHandler::NewL" );

    CMmNetMessHandler* netMessHandler = new ( ELeave ) CMmNetMessHandler();

    CleanupStack::PushL( netMessHandler );

    netMessHandler->iPhoNetSender = aPhoNetSender;

    netMessHandler->iMessageRouter = aMessageRouter;

    netMessHandler->iMmUiccMessHandler = aUiccMessHandler;

    netMessHandler->ConstructL();

    // NETWORK

    aPhoNetReceiver->RegisterL(

        netMessHandler,

        PN_MODEM_NETWORK );

    // GPDS

    aPhoNetReceiver->RegisterL(

        netMessHandler,

        PN_GPDS,

        GPDS_RADIO_ACTIVITY_IND );

    aPhoNetReceiver->RegisterL(

        netMessHandler,

        PN_GPDS,

        GPDS_CONTEXT_DEACTIVATE_IND );

    // INFO

#ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING

    aPhoNetReceiver->RegisterL(

        netMessHandler,

        PN_INFO,

        INFO_PP_READ_RESP );

#else /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */

/*  To be replaced with INFO_PP_DATA_READ_RESP

    aPhoNetReceiver->RegisterL(

        netMessHandler,

        PN_MODEM_INFO,

        INFO_PP_READ_RESP );

*/

#endif /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */

    // PERMANENT_DATA

    /*aPhoNetReceiver->RegisterL(

        netMessHandler,

        PN_PERMANENT_DATA,

        PERM_PM_RECORD_WRITE_RESP );

    aPhoNetReceiver->RegisterL(

        netMessHandler,

        PN_PERMANENT_DATA,

        PERM_PM_RECORD_READ_RESP ); To be done in CPS */

    CleanupStack::Pop( netMessHandler );

    return netMessHandler;

    }

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

// CMmNetMessHandler::ConstructL

// Symbian 2nd phase constructor. Initialises internal attributes.

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

//

void CMmNetMessHandler::ConstructL()

    {

TFLOGSTRING("TSY: CMmNetMessHandler::ConstructL()");

OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_CONSTRUCTL, "CMmNetMessHandler::ConstructL" );

    iNetOperatorNameHandler = CMmNetOperatorNameHandler::NewL(

        this,

        iMmUiccMessHandler );

    // Delay timer for completion of Packet transfer state

    iDelayTimer = CDelayTimer::NewL( this );

    // Selection method is at this point unknown

    iSelectionMethod = NET_SELECT_MODE_UNKNOWN;

    // No cancel request has been issued yet

    iSelectNetworkCancelIssued = EFalse;

    iSearchNetworkCancelIssued = EFalse;

    // Initialize to EFalse

    iImsPinVerifyRequired = EFalse;

    iIsimUsed = EFalse;

    iMNClength = 0;

    iNetworkMode = RMobilePhone::ENetworkModeUnknown;

    iNetworkAccess = RMobilePhone::ENetworkAccessUnknown;

    iCell_DCH = EFalse;

    iPacketTransfer = EFalse;

    iNetMessageHandlingOngoing = EFalse;

    // Request network signal strength (RSSI)

    NetRssiGetReq();

    }

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

// CMmNetMessHandler::~CMmNetMessHandler

// Destructor

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

//

CMmNetMessHandler::~CMmNetMessHandler()

    {

TFLOGSTRING("TSY: CMmNetMessHandler::~CMmNetMessHandler() - End");

OstTrace0( TRACE_NORMAL, DUP1_CMMNETMESSHANDLER_CMMNETMESSHANDLER, "CMmNetMessHandler::~CMmNetMessHandler" );

    delete iNetOperatorNameHandler;

    for ( TInt i = 0; i < iNetMessageQueue.Count(); i++ )

        {

        delete iNetMessageQueue[i];

        }

    iNetMessageQueue.Close();

    // Delete delay timer

    if ( iDelayTimer )

        {

        delete iDelayTimer;

        }

    }

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

// CMmNetMessHandler::ProcessUiccMsg

// Handles data received from UICC server

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

//

TInt CMmNetMessHandler::ProcessUiccMsg(

    TInt aTraId,

    TInt aStatus,

    TUint8 /*aDetails*/,

    const TDesC8& aFileData )

    {

TFLOGSTRING3("TSY: CMmNetMessHandler::ProcessUiccMsg, transaction ID: %d, status: %d", aTraId, aStatus );

OstTraceExt2( TRACE_NORMAL, CMMNETMESSHANDLER_PROCESSUICCMSG, "CMmNetMessHandler::ProcessUiccMsg;aTraId=%d;aStatus=%d", aTraId, aStatus );

    TInt ret( KErrNone );

    switch( aTraId )

        {

        case ETrIdReadCipheringIndicatorStatus:

            {

            UiccReadCiResp( aStatus, aFileData );

            break;

            }

        case ETrIdReadCsDataEhplmn:

            {

            UiccCsReadEhpmlnResp( aStatus, aFileData );

            break;

            }

        case ETrIdReadCsDataHplmn:

            {

            UiccCsReadHpmlnResp( aStatus, aFileData );

            break;

            }

        default:

            {

TFLOGSTRING("TSY: CMmNetMessHandler::ProcessUiccMsg - unknown transaction ID" );

OstTrace0( TRACE_NORMAL, DUP1_CMMNETMESSHANDLER_PROCESSUICCMSG, "CMmNetMessHandler::ProcessUiccMsg - - unknown transaction ID" );

            break;

            }

        }

    return ret;

    }

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

// CMmNetMessHandler::ExtFuncL

// Dispatches Etel requests to DOS level handlers

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

//

TInt CMmNetMessHandler::ExtFuncL

        (

        TInt aIpc, // Ipc number

        const CMmDataPackage* aDataPackage // Packed data

        )

    {

TFLOGSTRING2("TSY: CMmNetMessHandler::ExtFuncL - Ipc: %d", aIpc);

OstTrace1( TRACE_NORMAL, CMMNETMESSHANDLER_EXTFUNCL, "CMmNetMessHandler::ExtFuncL;aIpc=%d", aIpc );

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

    // NOTE:

    //

    // LICENSEE SPECIFIC MESSAGE HANDLER IMPLEMENTATION STARTS HERE

    //

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

    TInt ret( KErrNone );

    TUint8 transId( KNetTransId );

      switch ( aIpc )

        {

        case EMobilePhoneSetNetworkSelectionSetting:

            {

            // Unpack the parameters for this case

            RMobilePhone::TMobilePhoneNetworkSelectionV1* networkSetting( NULL );

            aDataPackage->UnPackData( &networkSetting );

            // Forward the request to specific method

            NetNetworkSelectModeSetReq( transId, *networkSetting );

            break;

            }

        case EMobilePhoneSelectNetwork:

            {

            // Unpack parameters

            TBool* isManual( NULL );

            RMobilePhone::TMobilePhoneNetworkManualSelection* manualSelection( NULL );

            aDataPackage->UnPackData( &isManual, &manualSelection );

            // Forward the request to the specific method

            NetSetReq( transId,

                *isManual,

                manualSelection->iNetwork.Left( 4 ), // Operator code

                manualSelection->iCountry.Left( 3 ) ); // Country code

            break;

            }

        case EMobilePhoneSelectNetworkCancel:

            {

            NetSetCancelReq( transId );

            break;

            }

        case EMobilePhoneGetDetectedNetworksV2Phase1:

            {

            NetModemAvailableGetReq( transId );

            break;

            }

        case EMobilePhoneGetDetectedNetworksCancel:

            {

            NetAvailableCancelReq( transId );

            break;

            }

        case EMobilePhoneGetNetworkRegistrationStatus:

            {

            // We need to get the network mode before we get the registration

            // status as this second message doesn't inform in which mode

            // the network is working.

            // The net server only serves one request at a time, so there won't

            // be any race condition and mode will be available always in first

            // place.

            NetRatReq( transId );

            NetModemRegStatusGetReq( transId );

            break;

            }

        case EMobilePhoneGetHomeNetwork:

            {

            UiccCsReadReq();

            break;

            }

        case EMobilePhoneGetCipheringIndicatorStatus:

            {

            UiccReadCiReq();

            break;

            }

        default:

            {