/*

* Copyright (c) 2008 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 "cmmnetoperatornamehandler.h"

#include "cmmmessagerouter.h"

#include "cmmphonemesshandler.h"

#include "cmmphonetsender.h"

#include "cmmstaticutility.h"

#include "toperatornames.h"

#include "tsylogger.h"

#include <etelmm.h>

#include <mmlist.h> // For network list functionality

#include <net_modemisi.h>

#include <infoisi.h>

#include <product_profile_definitions.h>

#include <tisi.h>

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

#include "osttracedefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmmnetoperatornamehandlertraces.h"

#endif

// EXTERNAL DATA STRUCTURES

    //None

// EXTERNAL FUNCTION PROTOTYPES

    //None

// CONSTANTS

#ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING

const TUint8 KNetTransId = 0x04; // TO BE DONE WITH INFO_PP_DATA_READ_REQ

#endif /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */

const TUint8 KNetPadding = 0x00;

// PNN record indentifiers in HPLMN.

const TUint8 KNetNoHplmnPnnRecordNumber = 0x00;

const TUint8 KNetHplmnPnnRecordNumber = 0x01;

// Max buffer length for Operator name.

const TInt KMaxLengthOfOperatorName = 124;

// Max data string length in FULL_NAME or SHORT_NAME.

// Length is enough big to hold max data length converted

// to 7-bit characters.

const TInt KDataStringMaxLength = 300;

// Shifting & masking.

const TUint8 KSiftedSixTimes = 0x06;

const TUint8 KSpareBitsMask = 0x07; // Mask bits 1-3.

const TUint8 KCountryInitialsMask = 0x08; // Mask bit 4.

const TUint8 KCodingSchemeMask = 0x70; // Mask bits 5-7.

// Wild char mask for BCD code checking.

const TUint8 KBCDWildChar = 0x0D;

// Character mask.

const TUint8 KBCDOneCharMask = 0x0F;

// Extended table.

const TUint8 KExtendedTable = 0x1B;

// Message data buffer length for PMM write request (74 bytes).

const TUint8 KPmmDataLengthWriteReq = 0x4A;

// Message data buffer length for PMM read request (14 bytes).

const TUint8 KPmmDataLengthReadReq = 0x0E;

// NITZ data length for PMM (64 bytes).

const TUint32 KNitzPmmDataLength = 0x00000040;

// NITZ data read offset values for PMM.

const TUint32 KNitzPmmDataOffset = 0x00000000;

//const TUint8 KNitzPmmLongNameOffset = 0x04; To be done in CPS

//const TUint8 KNitzPmmShortNameOffset = 0x2C; To be done in CPS

// NITZ name lengths in 8bit buffers.

//const TUint8 KNitzPmmLongNamelength8Bit = 40; To be done in CPS

//const TUint8 KNitzPmmShortNameLength8Bit = 20; To be done in CPS

// MACROS

    //None

// LOCAL CONSTANTS AND MACROS

    //None

// MODULE DATA STRUCTURES

// GSM 7-bit -> unicode translation table.

// See 3GPP TS 23.038.

const TUint16 KUnicode[128] =

    {

    0x0040, 0x00A3, 0x0024, 0x00A5, 0x00E8, 0x00E9, 0x00F9, 0x00EC,

    0x00F2, 0x00E7, 0x000A, 0x00D8, 0x00F8, 0x000D, 0x00C5, 0x00E5,

    0x0394, 0x005F, 0x03A6, 0x0393, 0x039B, 0x03A9, 0x03A0, 0x03A8,

    0x03A3, 0x0398, 0x039E, 0x00A0, 0x00C6, 0x00E6, 0x00DF, 0x00C9,

    0x0020, 0x0021, 0x0022, 0x0023, 0x00A4, 0x0025, 0x0026, 0x0027,

    0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,

    0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,

    0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,

    0x00A1, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,

    0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,

    0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,

    0x0058, 0x0059, 0x005A, 0x00C4, 0x00D6, 0x00D1, 0x00DC, 0x00A7,

    0x00BF, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,

    0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,

    0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,

    0x0078, 0x0079, 0x007A, 0x00E4, 0x00F6, 0x00F1, 0x00FC, 0x00E0

    };

// LOCAL FUNCTION PROTOTYPES

    //None

// FORWARD DECLARATIONS

    //None

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

    //None

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

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

// CMmNetOperatorNameHandler::CMmNetOperatorNameHandler

// C++ default constructor

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

//

CMmNetOperatorNameHandler::CMmNetOperatorNameHandler()

    {

TFLOGSTRING("TSY: CMmNetOperatorNameHandler::CMmNetOperatorNameHandler()");

OstTrace0( TRACE_NORMAL, CMMNETOPERATORNAMEHANDLER_CMMNETOPERATORNAMEHANDLER, "CMmNetOperatorNameHandler::CMmNetOperatorNameHandler" );

    }

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

// CMmNetOperatorNameHandler::NewL

// Two-phased constructor.

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

//

CMmNetOperatorNameHandler* CMmNetOperatorNameHandler::NewL

        (

        CMmNetMessHandler* aNetMessHandler // Pointer to the NetMessHandler.

        )

    {

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

OstTrace0( TRACE_NORMAL, CMMNETOPERATORNAMEHANDLER_NEWL, "CMmNetOperatorNameHandler::NewL" );

    CMmNetOperatorNameHandler* netOperatorNameHandler =

        new ( ELeave ) CMmNetOperatorNameHandler();

    CleanupStack::PushL( netOperatorNameHandler );

    netOperatorNameHandler->iNetMessHandler = aNetMessHandler;

    netOperatorNameHandler->ConstructL();

    CleanupStack::Pop( netOperatorNameHandler );

    return netOperatorNameHandler;

    }

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

// CMmNetOperatorNameHandler::ConstructL

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

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

//

void CMmNetOperatorNameHandler::ConstructL()

    {

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

OstTrace0( TRACE_NORMAL, CMMNETOPERATORNAMEHANDLER_CONSTRUCTL, "CMmNetOperatorNameHandler::ConstructL" );

    // Initialization of NITZ data.

    iNitzName.iMCC = 0;

    iNitzName.iMNC = 0;

    iNitzName.iLongName.Zero();

    iNitzName.iShortName.Zero();

    // Initialization of EONS data.

    iEonsName.iMCC = 0;

    iEonsName.iMNC = 0;

    iEonsName.iLongName.Zero();

    iEonsName.iShortName.Zero();

    iEonsName.iPNNIdentifier = 0;

    // Initialization of NITZ name stored to PMM.

    iNitzNamePmm.iMCC = 0;

    iNitzNamePmm.iMNC = 0;

    iNitzNamePmm.iLongName.Zero();

    iNitzNamePmm.iShortName.Zero();

    // Initialize CustomAPI values.

    iOperNameInfo.iType = RMmCustomAPI::EOperatorNameFlexiblePlmn;

    iOperNameInfo.iName.Zero();

    // Initialization of Operator Name String (ONS).

    iOperatorNameString.Zero();

    // Operator PLMN list available flag initialization.

    iOplListAvailable = EFalse;

    // OPL rules read flag initialization.

    iOplRulesRead = EFalse;

    // OPL rule match flag initialization.

    iOplRuleMatch = EFalse;

    // Initialize.

    iFromGetOperatorName = EFalse;

    iFromGetManualSearchOperatorName = EFalse;

    iManualSearchIndexValue = 0;

    // Initialization of PP bit value, initialized to non used value.

#ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING

    iInfoPpEonsFeatValue = 0xFF;

#endif /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */

    // TO BE DONE WITH INFO_PP_DATA_READ_RESP

    iInfoPpEonsFeatValue = INFO_PP_EONS_FEAT_0;

    // Read INFO_PP_EONS_FEAT PP bit value.

    InfoPpReadReq();

    // Read NITZ data from PMM.

    PermPmRecordReadReq();

    }

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

// CMmNetOperatorNameHandler::~CMmNetOperatorNameHandler

// Destructor

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

//

CMmNetOperatorNameHandler::~CMmNetOperatorNameHandler()

    {

TFLOGSTRING("TSY: CMmNetOperatorNameHandler::~CMmNetOperatorNameHandler()");

OstTrace0( TRACE_NORMAL, DUP1_CMMNETOPERATORNAMEHANDLER_CMMNETOPERATORNAMEHANDLER, "CMmNetOperatorNameHandler::~CMmNetOperatorNameHandler" );

    // Closes the array and frees all memory allocated to the array.

    iOperatorPlmnListTable.Close();

    iManualSearchNetworkList.Close();

    iManualSearchDataList.Close();

    }

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

// CMmNetOperatorNameHandler::NetNitzNameInd

// Breaks a NET_NITZ_NAME_IND ISI-message.

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

//

void CMmNetOperatorNameHandler::NetNitzNameInd

        (

        const TIsiReceiveC& aIsiMessage

        )

    {

TFLOGSTRING("TSY: CMmNetOperatorNameHandler::NetNitzNameInd");

OstTrace0( TRACE_NORMAL, CMMNETOPERATORNAMEHANDLER_NETNITZNAMEIND, "CMmNetOperatorNameHandler::NetNitzNameInd" );

    // Reset NITZ data.

    iNitzName.iMCC = 0;

    iNitzName.iMNC = 0;

    iNitzName.iLongName.Zero();

    iNitzName.iShortName.Zero();

    // Initialize.

    TUint tempMCC( 0 ); // Mobile Country Code

    TUint tempMNC( 0 ); // Mobile Network Code

    TUint sbStartOffSet( 0 );

    RMobilePhone::TMobilePhoneNetworkCountryCode countryCode;

    RMobilePhone::TMobilePhoneNetworkIdentity networkId;

    // Get the operator code. Size is 3 bytes.

    TPtrC8 operatorCode( aIsiMessage.GetData(

        ISI_HEADER_SIZE + NET_NITZ_NAME_IND_OFFSET_OPERATORCODE,

        3 ) );

    // Map the operator code and country code to symbian values.

    iNetMessHandler->MapOperatorAndCountryCode(

                         operatorCode,

                         networkId,

                         countryCode );

    // Convert descriptor contained number to integer.

    CMmStaticUtility::GetIntFromDescriptor( tempMCC, countryCode );

    CMmStaticUtility::GetIntFromDescriptor( tempMNC, networkId );

    // Store Country Code and Network Code.

    iNitzName.iMCC = tempMCC;

    iNitzName.iMNC = tempMNC;

    // Get NET_FULL_NITZ_NAME sub block.

    TInt retValue( aIsiMessage.FindSubBlockOffsetById(

        ISI_HEADER_SIZE + SIZE_NET_NITZ_NAME_IND,

        NET_FULL_NITZ_NAME,

        EIsiSubBlockTypeId8Len8,

        sbStartOffSet ) );

    if ( KErrNone == retValue )

        {

TFLOGSTRING("TSY: CMmNetOperatorNameHandler::NetNitzNameInd - NET_FULL_NITZ_NAME sub block");

OstTrace0( TRACE_NORMAL, DUP2_CMMNETOPERATORNAMEHANDLER_NETNITZNAMEIND, "CMmNetOperatorNameHandler::NetNitzNameInd - NET_FULL_NITZ_NAME sub block" );

        // Temporaly buffer for Long NITZ name.

        TBuf<KMaxLengthOfOperatorName> longNitzName;

        // Get data length.

        TUint8 dataLength( aIsiMessage.Get8bit(

            sbStartOffSet + NET_FULL_NITZ_NAME_OFFSET_DATALENGTH ) );

        // Get NITZ data from data field.

        TPtrC8 nitzFullNameData( aIsiMessage.GetData(

            sbStartOffSet + NET_FULL_NITZ_NAME_OFFSET_DATA,

            dataLength ) );

        // Convert NITZ data field to NITZ operator name.

        ConvertOperatorName(

            ENetNitzName,

            iNitzName.iMCC,

            nitzFullNameData,

            longNitzName );

        // Store NITZ Long name.

        iNitzName.iLongName.Copy( longNitzName.Left(

            iNitzName.iLongName.MaxLength() ) );

        }

    // Get NET_SHORT_NITZ_NAME sub block.

    retValue = aIsiMessage.FindSubBlockOffsetById(

        ISI_HEADER_SIZE + SIZE_NET_NITZ_NAME_IND,

        NET_SHORT_NITZ_NAME,

        EIsiSubBlockTypeId8Len8,

        sbStartOffSet );

    if ( KErrNone == retValue )

        {

TFLOGSTRING("TSY: CMmNetOperatorNameHandler::NetNitzNameInd - NET_SHORT_NITZ_NAME sub block");

OstTrace0( TRACE_NORMAL, DUP1_CMMNETOPERATORNAMEHANDLER_NETNITZNAMEIND, "CMmNetOperatorNameHandler::NetNitzNameInd - NET_SHORT_NITZ_NAME sub block" );

        // Temporaly buffer for Short NITZ name.

        TBuf<KMaxLengthOfOperatorName> shortNitzName;

        // Get data length.

        TUint8 dataLength( aIsiMessage.Get8bit(

            sbStartOffSet + NET_SHORT_NITZ_NAME_OFFSET_DATALENGTH ) );

        // Get NITZ data from data field.

        TPtrC8 nitzShortNameData( aIsiMessage.GetData(

            sbStartOffSet + NET_SHORT_NITZ_NAME_OFFSET_DATA,

            dataLength ) );

        // Convert NITZ data field to NITZ operator name.

        ConvertOperatorName(

            ENetNitzName,

            iNitzName.iMCC,

            nitzShortNameData,

            shortNitzName );

        // Store NITZ Short name.

        iNitzName.iShortName.Copy( shortNitzName.Left(

            iNitzName.iShortName.MaxLength() ) );

        }

TFLOGSTRING2("TSY: CMmNetOperatorNameHandler::NetNitzNameInd - iNitzName.iMCC: %d", iNitzName.iMCC);

TFLOGSTRING2("TSY: CMmNetOperatorNameHandler::NetNitzNameInd - iNitzName.iMNC: %d", iNitzName.iMNC);

TFLOGSTRING2("TSY: CMmNetOperatorNameHandler::NetNitzNameInd - iNitzName.iLongName: %S", &iNitzName.iLongName);

TFLOGSTRING2("TSY: CMmNetOperatorNameHandler::NetNitzNameInd - iNitzName.iShortName: %S", &iNitzName.iShortName);

OstTrace1( TRACE_NORMAL, DUP3_CMMNETOPERATORNAMEHANDLER_NETNITZNAMEIND, "CMmNetOperatorNameHandler::NetNitzNameInd - iNitzName.iMCC=%u", iNitzName.iMCC );

OstTrace1( TRACE_NORMAL, DUP4_CMMNETOPERATORNAMEHANDLER_NETNITZNAMEIND, "CMmNetOperatorNameHandler::NetNitzNameInd - iNitzName.iMNC=%u", iNitzName.iMNC );

OstTraceExt1( TRACE_NORMAL, DUP5_CMMNETOPERATORNAMEHANDLER_NETNITZNAMEIND, "CMmNetOperatorNameHandler::NetNitzNameInd - iNitzName.iLongName=%S", iNitzName.iLongName );

OstTraceExt1( TRACE_NORMAL, DUP6_CMMNETOPERATORNAMEHANDLER_NETNITZNAMEIND, "CMmNetOperatorNameHandler::NetNitzNameInd - iNitzName.iShortName=%S", iNitzName.iShortName );

    // Compare NITZ name got in NET_NITZ_NAME_IND to stored values in PMM.

    CompareNitzNameToPmmValues();

    }

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

// CMmNetOperatorNameHandler::ConvertOperatorName

// Convert received data to operator name string according to coding scheme.

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

//

void CMmNetOperatorNameHandler::ConvertOperatorName

        (

        TNetOperatorNameType aNameType, // Name type

        TUint aMCC, // Country code

        TPtrC8& aNameData, // Operator name data

        TDes& aOperatorName // Converted operator name

        )

    {

TFLOGSTRING("TSY: CMmNetOperatorNameHandler::ConvertOperatorName");

OstTrace0( TRACE_NORMAL, CMMNETOPERATORNAMEHANDLER_CONVERTOPERATORNAME, "CMmNetOperatorNameHandler::ConvertOperatorName" );

    // Network Name information element.

    // See 3GPP 24.008 figure 10.5.80 and table 10.5.94.

    //

    //   8   7   6   5   4   3   2   1

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

    // |   |     Network Name IEI      |octet 1

    // |-------------------------------|

    // |Length of Network name contents|octet 2

    // |-------------------------------|

    // |ext|  coding   |Add| number of |

    // | 1 |  scheme   |CI | spare bits|octet 3

    // |-------------------------------|

    // |                               |octet 4

    // |          Text String          |  to

    // |                               |octet n

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

    // Initialze values for offsets.

    TInt offsetValueForOctet2( 0 );

    TInt offsetValueForOctet3( 0 );

    TInt offsetValueForOctet4( 0 );

    // Initialize length of Text String.

    TInt lengthOfTextString( 0 );

    // Operator name max length.

    TInt operatorNameMaxLength( aOperatorName.MaxLength() );

    // Check what name type is handled.

    if ( ENetEonsName == aNameType )

        {

        // EONS name data doesn't include Network Name IEI octed

        // and Length of Network Name contents octed,

        // so we need adjust offsets for reading correct position.

        offsetValueForOctet3 = 0;

        offsetValueForOctet4 = 1;

        // Get length of Text String.

        // Data includes also octet3, take that out

        // for real length of text string.

        lengthOfTextString = aNameData.Length() - 1;

        }

    else if ( ENetNitzName == aNameType )

        {

        // NITZ name data handling.

        // Offsets are according to figure 10.5.80.

        offsetValueForOctet2 = 1;

        offsetValueForOctet3 = 2;

        offsetValueForOctet4 = 3;

        // Get length of Text String.

        // Length of Network name contents includes also octet3,

        // take that out for real length of text string.

        lengthOfTextString = aNameData[offsetValueForOctet2] - 1;

        }

    // Get number of spare bits in last octet.

    // Mask bits 1-3 from octet 3.

    TUint8 numberOfSpareBits(

        aNameData[offsetValueForOctet3] & KSpareBitsMask );

    // Check out if Country's initials is needed.

    // Mask bit 4 from octet 3.

    TBool countryInitialsNeeded(

        aNameData[offsetValueForOctet3] & KCountryInitialsMask );

    // Get used Coding Scheme.

    // Mask bits 5-7 from octet 3.

    TUint8 codingSchemeInUse(

        aNameData[offsetValueForOctet3] & KCodingSchemeMask );

    // Pointer to operator name Text String.

    TPtrC8 textString( aNameData.Mid(

        offsetValueForOctet4,

        lengthOfTextString ) );

    // Add country's initials if needed to operator name string.

    if ( countryInitialsNeeded )

        {

TFLOGSTRING("TSY: CMmNetOperatorNameHandler::ConvertOperatorName - Country's Initials needed");

OstTrace0( TRACE_NORMAL, DUP1_CMMNETOPERATORNAMEHANDLER_CONVERTOPERATORNAME, "CMmNetOperatorNameHandler::ConvertOperatorName - Country's Initials needed" );

        // Initialize ret value.

        TInt ret( KErrNotFound );

        // Country's initials is needed.

        ret = TOperatorNames::GetCountryID( aMCC, aOperatorName );

        // Country was found and initials has added.

        if ( KErrNone == ret )

            {

            // Add also 'space' between Country's initials

            // and operator name string.

            aOperatorName.Append(' ');

            }

        // No else.

        }

    // Check Coding Scheme and convert string as needed.

    if ( EGSMDefaultAlphabetCoding == codingSchemeInUse )

        {

TFLOGSTRING("TSY: CMmNetOperatorNameHandler::ConvertOperatorName - 7-Bit coding used");

OstTrace0( TRACE_NORMAL, DUP2_CMMNETOPERATORNAMEHANDLER_CONVERTOPERATORNAME, "CMmNetOperatorNameHandler::ConvertOperatorName - 7-Bit coding used" );

        // Used coding is GSM 7-bit Default alphabet.

        //

        // Calculate correct value of GSM 7-bit characters.

        // numberOf7BitChars includes count of 7-bit characters

        // in 8-bit text string buffer.

        TInt numberOf7BitChars(

            ( ( lengthOfTextString * 8 ) - numberOfSpareBits ) / 7 );

        // Temporaly buffer for 8-bit string.

        TBuf8<KDataStringMaxLength> string8Bit;

        // Convert string first to 8-bit format.

        Packed7to8Format( numberOf7BitChars, textString, string8Bit );

        // Convert 8-bit string to unicode 16-bit format.

        // Temporaly buffer for 16-bit string.

        TBuf<KDataStringMaxLength> converted16BitString;

        // Convert to 16-bit.

        ConvertGsm7ToUnicode16( converted16BitString, string8Bit );

        // Converted string length.

        TInt converted16BitStringLength( converted16BitString.Length() );

        // Append operator name Text String.

        for ( TInt i = 0;

            i < converted16BitStringLength && operatorNameMaxLength > aOperatorName.Length();

            i++ )

            {