/*

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

#include <ctsy/serviceapi/cmmsmsutility.h> // for kmaxamountofdigits

#include "tsylogger.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmmsmsgsmaddressTraces.h"

#endif

      // for logging purposes

//  External Data Structures  

//  External Function Prototypes  

//  LOCAL CONSTANTS AND MACROS 

const TUint8 KAddressMinLength = 2;

const TUint8 KAddressLengthAndTon = 2;

const TUint8 KDataByteInUnicode = 2;

const TUint8 KHalfByte = 4;

const TUint8 KLengthOfByte = 8;

const TUint8 KLengthOfPackedByte = 7;

const TUint8 KTwoCharInByte = 2;

//  MODULE DATA STRUCTURES  

//  Local Data Structures  

//  Local Function Prototypes  

// Converts semioct-code to character, semioctet can be 0x00 - 0x0F

#define GSMSMSSEMIOCTETTOCHAR( bcd )  gsmSmsSemiOctetToCharTable[ bcd ]

//  MEMBER FUNCTIONS

//=============================================================================

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

// CMmSmsGsmAddress::CMmSmsGsmAddress

// C++ constructor. Private (this class should not be instantiated).

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

// 

CMmSmsGsmAddress::CMmSmsGsmAddress

        (

        //None

        )

    {

TFLOGSTRING("TSY: CMmSmsGsmAddress::CMmSmsGsmAddress");

    //none

    }

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

// CMmSmsGsmAddress::GsmConvUnicodeTo0340Addr

// Converts type of number, numbering plan identification and

// phone number given in unicode string to the Gsm 03.40 

// standard

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

//

void CMmSmsGsmAddress::GsmConvUnicodeTo0340Addr

        (

        TUint8 aTon,            //Type of number

        TUint8 aNpi,            //Numbering plan identification

        TDes8& aDest,           //Service center address

        TDesC16 const& aSource  //Telephone number

        )    

    {

TFLOGSTRING("TSY: CMmSmsGsmAddress::GsmConvUnicodeTo0340Addr");

    if ( 0 != aSource.Length() )

        {

        GsmConvUnicodeToAddr( aTon, aNpi, aDest, aSource, ETrue );  

        }

    else

        {

        // Address length of 0 is a special case

        aDest.Append( 0 );      

        // Type-of-Address: TON = Unknown, NPI = ISDN/telephone num plan

        aDest.Append( 0x81 );  

        }

    }

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

// CMmSmsGsmAddress::GsmConv0340AddrToUnicode

// This function converts an address format string specified in 

// GSM 03.40 into unicode string

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

//

void CMmSmsGsmAddress::GsmConv0340AddrToUnicode

        ( 

        TDes& aDest,                            //Service center address

        TDesC8 const& aSource,                  //Telephone number

        RMobilePhone::TMobileTON& aTon,         //Type of number

        RMobilePhone::TMobileNPI& aNpi          //Telephone number

        )

    {

TFLOGSTRING("TSY: CMmSmsGsmAddress::GsmConv0340AddrToUnicode");

    if ( KAddressMinLength <= aSource.Length() ) 

        {

        //Address length and address type fields included

        GsmConvAddrToUnicode( aDest, aSource, aTon, aNpi, ETrue );

        }

    else

        {

        //Corrupted address

        aDest.SetLength( 0 );

        aTon = RMobilePhone::EUnknownNumber;

        aNpi = RMobilePhone::EUnknownNumberingPlan;

        }

    }

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

// CMmSmsGsmAddress::GsmConvUnicodeTo0411Addr

// Converts type of number, numbering plan identification and

// phone number given in unicode string to the Gsm 04.11 

// standard

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

//

void CMmSmsGsmAddress::GsmConvUnicodeTo0411Addr

        (

        TUint8 aTon,            //Type of number

        TUint8 aNpi,            //Numbering plan identification

        TDes8& aDest,           //Service center address

        TDesC16 const& aSource  //Telephone number

        )

    { 

TFLOGSTRING("TSY: CMmSmsGsmAddress::GsmConvUnicodeTo0411Addr");

    if ( 0 != aSource.Length() )

        {

        GsmConvUnicodeToAddr( aTon, aNpi, aDest, aSource, EFalse );

        }

    else

        {

        // Address length of 0 is a special case: no address type is given.

        aDest.Append( 0 );

        }

    }

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

// CMmSmsGsmAddress::GsmConv0411AddrToUnicode

// This function converts an address format string specified in 

// GSM 04.11 into unicode string

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

//

void CMmSmsGsmAddress::GsmConv0411AddrToUnicode

        (

        TDes& aDest,                        //Destination

        TDesC8 const& aSource,              //Source

        RMobilePhone::TMobileTON& aTon,     //Type of number

        RMobilePhone::TMobileNPI& aNpi      //Numbering plan identification

        )

    {

TFLOGSTRING("TSY: CMmSmsGsmAddress::GsmConv0411AddrToUnicode");

    if ( KAddressMinLength <= aSource.Length() )

        {

        //Address length and address type fields included

        GsmConvAddrToUnicode( aDest, aSource, aTon, aNpi, EFalse );

        }

    else

        {

        //No address type field

        aDest.SetLength( 0 );

        aTon = RMobilePhone::EUnknownNumber;

        aNpi = RMobilePhone::EUnknownNumberingPlan;

        }

    }

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

// CMmSmsGsmAddress::GsmConvUnicodeToAddr

// Converts type of number, numbering plan identification and

// phone number given in unicode string to the GSM 03.40 or

// 04.11 standard

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

//

void CMmSmsGsmAddress::GsmConvUnicodeToAddr

        (

        TUint8 aTon,             //Type of number

        TUint8 aNpi,             //Numbering plan identification

        TDes8& aDest,            //Service center address

        TDesC16 const& aSource,  //Telephone number

        TBool a0340Address       //GSM 03.40 address

        )

    { 

TFLOGSTRING4("TSY: CMmSmsGsmAddress::GsmConvUnicodeToAddr - number type: %d, numbering plan: %d, number: %S", aTon, aNpi, &aSource);

TFLOGSTRING2("TSY: CMmSmsGsmAddress::GsmConvUnicodeToAddr - GSM 03.40 address: %d", a0340Address);

    //get address length (always < 255)

    TUint8 numberLength( static_cast< TUint8 >( aSource.Length() ) );

    TUint8 destLength( numberLength );

    TInt i( 0 );

    /*  Solve type of address

        Type of Address field format is as follows:

           7      6     5     4      3      2       1       0    bit

        |     |      |     |     |      |       |       |       |

        |  1  | Type of number   | Numbering-plan-identification|

        |     |      |     |     |      |       |       |       |

    */

    //type of number is three bits from left and fourth bit must be '1'

    TUint8 typeOfNumber( TUint8( aTon | 0x08 ) );

    //move four bit to the left

    typeOfNumber = TUint8( typeOfNumber << 4 );

    //numbering plan is four bits from left

    TUint8 numberingPlan( TUint8( aNpi & 0x0F ) );

    //set type of number and numbering plan to the typeOfNumber variable

    typeOfNumber = TUint8( typeOfNumber | numberingPlan );

    if ( RMobilePhone::EAlphanumericNumber == aTon )

        {

        TBuf8< KMaxLengthOfAddressData > addressData;

        TUint8 amountOfsemiOctets( 0 );

        GsmUnicodeAddrToAlphanumericAddr( 

            aSource, 

            addressData,

            amountOfsemiOctets );           

        //fill address length field

        if ( a0340Address )

            {

            //amount of used semi-octets in address data

            aDest.Append( amountOfsemiOctets );

            }

        else    //0411 address

            {

            //Actually alphanumeric address data for 0411 address is not 

            //supported (see GSM 24.011 and 24.008)...

            //Length of address data + length of address type field

            //lint -e{732} Warning about "loss of sign". 

            //Root cause is that TDesC::Length() returns a signed TInt

            aDest.Append( addressData.Length() + 1 );

            }

        //add typeOfNumber to the buffer

        aDest.Append( typeOfNumber );

        //add address data to the buffer. 

        aDest.Insert( KAddressLengthAndTon, addressData );  

        }

    else

        {

        //number can contain character '+'

        if ( '+' == aSource[ i ] )

            {

            i++;

            destLength--;

            // Maximum amount of digits is 20 (3GPP TS 23.040)

            if ( KMaxAmountOfDigits < destLength ) 

                {                                                   

                destLength = KMaxAmountOfDigits;

                // + 1 comes from '+'

                numberLength = KMaxAmountOfDigits + 1;

                }

            }

        else

            {

            // Maximum amount of digits is 20 (3GPP TS 23.040)

            if ( KMaxAmountOfDigits < destLength ) 

                {                                                   

                destLength = KMaxAmountOfDigits;

                numberLength = KMaxAmountOfDigits;

                }

            }

        // calculate address length in bytes (always < 255). 

        // destLength + 1 ensures that there is enough space in case of odd

        // destLength. 

        TUint8 bufferLength( static_cast< TUint8 >( 

            ( destLength + 1 ) / 2 + KAddressLengthAndTon ) );

        //set buffer length

        aDest.SetLength( bufferLength );

        //add length to the buffer

        if ( a0340Address )

            {

            //amount of used semi-octets in address data

            aDest[ 0 ] = destLength;   

            }

        else

            {

            //length of whole address data - length of address length field

            aDest[ 0 ] = static_cast< TUint8 >( bufferLength - 1 );

            }

        //add typeOfNumber to the buffer

        aDest[1] = typeOfNumber; 

        //needed variables

        TUint8 numLsb( 0 );

        TUint8 numMsb( 0 );

        TInt index( KAddressLengthAndTon );

        //add numbers to the buffer

        for ( ; ( i + 1 ) < numberLength ; i += 2 )

            {

            numLsb = TUint8( aSource[ i ] - '0' );

            numMsb = TUint8( static_cast< TUint8 >( 

                aSource[ i + 1 ] - '0' ) << KHalfByte );

            aDest[index++] = TUint8( numLsb | numMsb );

            }

        //if numberLength is odd, last number is fixed with 0xF0

        if ( i < numberLength )

            {

            aDest[ index ] = TUint8( 0xF0 | ( aSource[ i ] - '0' ) );

            }

        }  

    }

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

// CMmSmsGsmAddress::GsmConvAddrToUnicode

// Converts GSM 03.40 or 04.11 address to type of number, 

// numbering plan identification and phone number given in 

// unicode string

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

//

void CMmSmsGsmAddress::GsmConvAddrToUnicode

        ( 

        TDes& aDest,                            //Service center address

        TDesC8 const& aSource,                  //Telephone number

        RMobilePhone::TMobileTON& aTon,         //Type of number

        RMobilePhone::TMobileNPI& aNpi,         //Telephone number

        TBool a0340Address                      //GSM 03.40 address

        )

    {

TFLOGSTRING("TSY: CMmSmsGsmAddress::GsmConvAddrToUnicode");

    TUint8  addrDataLength( 0 );

    TBool   halfs( ETrue );

    TInt    index( 0 );               

    TUint   num2( 0 );

    //Get amount of digits in address data

    if ( a0340Address )

        {

        addrDataLength = static_cast< TUint8> ( aSource[ index ] );

        }

    else    //04.11 address

        {

        addrDataLength = static_cast< TUint8 >( KDataByteInUnicode 

            * ( aSource[ index ] - 1 ) );

        }

    // Check if there are too many digits

    // Maximum amount of digits is 20 (3GPP TS 23.040)

    if ( KMaxAmountOfDigits < addrDataLength )

        {

        addrDataLength = KMaxAmountOfDigits;

        }

    index++;

    // Lets take type of number field

    TUint8 typeOfNum( aSource[ index ] );

    GsmFindOutTonAndNpi( typeOfNum, &aTon, &aNpi );

    if ( ( RMobilePhone::EAlphanumericNumber == aTon )

        && ( 0x00 != addrDataLength ) )

        {

        //Calculate address length in bytes. If statement above check's that

        //addrDataLength is not zero.

        TInt addrDataLengthInBytes( ( addrDataLength + 1 ) 

            / KDataByteInUnicode );

        //Get address data

        TPtrC8 addressData( aSource.Mid( 

            KAddressLengthAndTon, 

            addrDataLengthInBytes ) ); 

        //amountOfCharsInAddrData = amount of used bits / length of char

        TUint amountOfCharsInAddrData( ( addrDataLength * KHalfByte ) 

            / KLengthOfPackedByte );

        GsmAlphanumericAddrToUnicodeAddr( 

            addressData, 

            amountOfCharsInAddrData,

            aDest );

        }

    else

        {

        // Check if number is international number and addrDataLength is 

        // bigger than zero

        if ( ( RMobilePhone::EInternationalNumber == aTon ) 

            && ( 0x00 != addrDataLength ) )

            {

            aDest.Append( '+' );

            }

        index++;

        while ( addrDataLength-- )

            {

            if ( aSource.Length() > index )

                {

                if ( halfs )

                    {               

                    // Lets take only four bits from right

                    num2 = GSMSMSSEMIOCTETTOCHAR( aSource[ index ] & 0x0F );

                    aDest.Append( num2 );

                    halfs = EFalse;

                    }

                else

                    {

                    if ( ( 0x0F == ( aSource[ index ] >> KHalfByte ) ) && !a0340Address )

                        {

                        //If 04.11 address contains odd number of digits, 

                        //bits 5 to 8 of the last octet shall be filled with an end

                        //mark coded as "1111".

                        break;

                        }

                    halfs = ETrue;  // Lets take only four bits from left

                    num2 = GSMSMSSEMIOCTETTOCHAR( aSource[ index ] >> KHalfByte );

                    aDest.Append( num2 );

                    index++;

                    }

                } // if ( aSource.Length() > index )

            } // while

        }

TFLOGSTRING4("TSY: CMmSmsGsmAddress::GsmConvAddrToUnicode - result: number type: %d, numbering plan: %d, number: %S", aTon, aNpi, &aDest);

TFLOGSTRING2("TSY: CMmSmsGsmAddress::GsmConvAddrToUnicode - GSM 03.40 address", a0340Address);

    }

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

// CMmSmsGsmAddress::GsmFindOutTonAndNpi

// Converts type of number and numbering plan identification

// information from the type of address parameter to the 

// RMobilePhone::TMobileTON and RMobilePhone::TMobileNPI format

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

//

void CMmSmsGsmAddress::GsmFindOutTonAndNpi

        ( 

        TUint8 typeOfAddress,               //Type of address

        RMobilePhone::TMobileTON* ton,      //Type of number

        RMobilePhone::TMobileNPI* npi       //Numbering plan identification

        )     

    {

TFLOGSTRING2("TSY: CMmSmsGsmAddress::GsmFindOutTonAndNpi - address type: %d", typeOfAddress);

    TUint8 numberingPlanIdentification( static_cast< TUint8 >( 

        typeOfAddress & 0x0F ) );

    TUint8 temp( static_cast< TUint8 >( typeOfAddress >> KHalfByte ) );

    TUint8 typeOfNumber( static_cast< TUint8 >( temp & 0x07 ) );

    switch ( typeOfNumber )

        {

        case KInternationalNumber:

            {

            *ton = RMobilePhone::EInternationalNumber;

            break;

            }

        case KNationalNumber:

            {

            *ton = RMobilePhone::ENationalNumber;

            break;

            }

        case KNetworkSpecificNumber:

            {

            *ton = RMobilePhone::ENetworkSpecificNumber;

            break;

            }

        case KSubscriberNumber:

            {

            *ton = RMobilePhone::ESubscriberNumber;

            break;

            }

        case KAlphanumeric:

            {

            *ton = RMobilePhone::EAlphanumericNumber;

            break;

            }

        case KAbbreviatedNumber:

            {

            *ton = RMobilePhone::EAbbreviatedNumber;

            break;

            }

        default:

            {

TFLOGSTRING("TSY: CMmSmsGsmAddress::GsmFindOutTonAndNpi - unknown type of number");

            *ton = RMobilePhone::EUnknownNumber;

            break;

            }

        }

    switch ( numberingPlanIdentification )

        {

        case KIsdnTelephoneNumPlan: