// 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:

// Name        : TSatUtility.cpp

// Part of     : Common Sim Atk TSY / commonsimatktsy

// Sat Utility classes implementation.

// Version     : 1.0

//

// INCLUDE FILES

#include "tsatutility.h"        // Class header

#include <ctsy/serviceapi/cmmsmsutility.h>		// TON and NPI constants

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

// TSatUtility::TonAndNpi

// Map TON and NPI to RSat TON and NPI values

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

//

EXPORT_C void TSatUtility::TonAndNpi

        (

        const TInt aTonAndNpi,                

        RSat::TTypeOfNumber* aTon,      

        RSat::TNumberingPlan* aNpi      

        )

    {

    TInt ton( ( aTonAndNpi >> 4 ) & KTONMask ); // TON mask value 0x07

    switch ( ton )

        {

        case KTonUnknown:

            {

            *aTon = RSat::EUnknownNumber;

            break;

            }

        case KInternationalNumber:

            {

            *aTon = RSat::EInternationalNumber;

            break;

            }

        case KNationalNumber:

            {

            *aTon = RSat::ENationalNumber;

            break;                    

            }

        case KNetworkSpecificNumber:

            {

            *aTon = RSat::ENetworkSpecificNumber;

            break;

            }

        case KSubscriberNumber:

            {

            *aTon = RSat::EDedicatedNumber;

            break;

            }

        case KAlphanumeric:         

            {

            *aTon = RSat::EAlphanumericNumber;

            break;

            }

        case KAbbreviatedNumber:    

            {

            *aTon = RSat::EAbbreviatedNumber;

            break;

            }

        default:

            {

            *aTon = RSat::ETypeOfNumberNotSet;

            break;

            }

        }

    // Numbering plan

    TInt npi( aTonAndNpi & KNPIMask ); // NPI mask value 0x0F

    switch ( npi )

        {

        case KNpiUnknown:

            {

            *aNpi = RSat::EUnknownNumberingPlan;

            break;

            }

        case KIsdnTelephoneNumPlan:

            {

            *aNpi = RSat::EIsdnNumberPlan;

            break;

            }

        case KDataNumPlan:

            {

            *aNpi = RSat::EDataNumberPlan;

            break;

            }

        case KTelexNumPlan:

            {

            *aNpi = RSat::ETelexNumberPlan;

            break;

            }

        case KNationalNumPlan:

            {

            *aNpi = RSat::ENationalNumberPlan;

            break;

            }

        case KPrivateNumPlan:

            {

            *aNpi = RSat::EPrivateNumberPlan;

            break;

            }

        case KServiceCentreSpecificPlan1:

            {

            *aNpi = RSat::EServiceCentreSpecificPlan1;

            break;

            }

        case KServiceCentreSpecificPlan2:

            {

            *aNpi = RSat::EServiceCentreSpecificPlan2;

            break;

            }

        case KErmesNumPlan:    

            {

            *aNpi = RSat::EERMESNumberPlan;

            break;

            }

        default:

            {

            *aNpi = RSat::ENumberingPlanNotSet;

            break;

            }

        }

    }

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

// TSatUtility::Packed7to8Unpacked

// Converts 7-bit packed string to 8-bit unpacked format.

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

//

EXPORT_C TInt TSatUtility::Packed7to8Unpacked

        ( 

        const TPtrC8 aSource,   

        TDes8& aTarget    

        )

    {

    TInt ret( KErrNone );

    // The string is in packed GSM default alphabet format.

    // Converted to 8-bit format

    TUint8 maskRightPartOfCurrentByte( 0x7F );

    TUint8 shiftLeft( 0 );

    TUint8 leftPartFromPreviousByte( 0 );  

    TInt sourceLength = aSource.Length();  

    // Initialize the target string before starting

    aTarget.Zero();

    // Check out which string is the shortest and use its length as a limit

    TInt length ( Min( sourceLength, aTarget.MaxLength() ) );

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

        {

        TUint8 leftPartOfCurrentChar =  static_cast<TUint8>( ( 

            aSource[i] & maskRightPartOfCurrentByte ) << shiftLeft );

        // Append the character in the output text string

        aTarget.Append( leftPartOfCurrentChar | leftPartFromPreviousByte );  

        // Updates         

        if ( 6 == shiftLeft )

            {

            // After 6 shifts, the character is in bit7..bit1, 

            // therefore it has to be shifted one bit to the right.

            aTarget.Append( aSource[i] >> 1 );

            // Restart

            leftPartFromPreviousByte = 0;

            shiftLeft = 0;

            maskRightPartOfCurrentByte = 0x7F;            

            }

        else

            {

            leftPartFromPreviousByte = static_cast<TUint8>( ( 

                aSource[i] ) >> ( 7-shiftLeft ) );

            maskRightPartOfCurrentByte = static_cast<TUint8>( 

                maskRightPartOfCurrentByte >> 1 );

            shiftLeft++;

            } 

        }   

    // Whe should still notify the requesting method about exceeding the length

    if ( length < sourceLength )

        {

        ret = KErrOverflow;

        }

    return ret;

    }

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

// TSatUtility::UCSToPacked7

// Converts UCS2 string to 7-bit packed format

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

//

EXPORT_C void TSatUtility::UCSToPacked7

        ( 

        const TPtrC aInput,   

        TDes8& aOutput   

        )

    {

    TBuf8<KMaxUssdStringLengthInBytes> string;

    // This method interrupts converting if the target buffer is full, so

    // the length can not be exceeded

    ConvertUnicode16To7Bit( aInput, string ); 

    TUint8 move( 0 );

    TInt i( 0 );

    TInt length( string.Length() );

    // If the input data was too long, some data will miss from the end here

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

        {

        // Get first character

        TUint8 char1 = static_cast<TUint8>( string[i] >> move ); 

        TUint8 char2;

        if ( ( i + 1 ) < length )

            {

            // Get next character

            char2 = static_cast<TUint8>( string[i + 1]  << ( 7 - move ) );

            }

        else

            {

            // No more characters

            char2 = 0;

            }

        // Append packed character

        aOutput.Append( static_cast<TUint8>( char1 | char2 ) );

        if ( ( 6 == move ) && char2 )

            {

            i++;

            move = 0;

            }

        else

            {

            move++;

            }

        }

    if ( !( ( length + 1 ) % 8 ) )

        {

        // If the total number of characters in the text string equals (8n-1) 

        // where n=1,2,3 etc. then there are 7 spare bits at the end of the 

        // message. To avoid the situation where the receiving entity confuses

        // 7 binary zero pad bits as the @ character, the carriage return 

        // (i.e. <CR>) character shall be used for padding in this situation,

        // as defined in TS 23.038 [5].

        aOutput[  aOutput.Length() - 1 ] = static_cast<TUint8>( 

            aOutput[ aOutput.Length() - 1 ] | KCrShiftedOneBitToLeft );

        }

    }

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

// TSatUtility::BCDToAscii

// Converts BCD string to ASCII format

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

//

EXPORT_C TInt TSatUtility::BCDToAscii		

        ( 

        const TPtrC8 aInput,  

        TDes8& aOutput   

        )

    {

    TInt ret( KErrNone );

    // Convert Abbreviated dialling numbers format back to ASCII format.

    // See 3GPP TS 11.11, EFadn

    aOutput.Zero();

    // Check out which string is the shortest and use its length as a limit

    TInt length ( Min( aInput.Length(), aOutput.MaxLength() ) );

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

        {

        // Two bcd string chars are coded in one byte,

        // 1st char is in low nibble and 2nd is in high nibble

        // if the high nibble doesn't contain a char it's value is 0xf

        TUint8 byte = aInput[i];

        aOutput.Append( KAscii[byte & 0x0F] );

        if ( KMaskF0 != ( byte & KMaskF0 ) )

            {

            aOutput.Append( KAscii[byte >> 4] );

            }

        }

    // Whe should still notify the requesting method about exceeding the length

    if ( length < aInput.Length() )

        {

        ret = KErrOverflow;

        }    

    return ret;

    }

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

// TSatUtility::AsciiToBCD

// Convert ASCII string to binary coded decimal, invalid characters are dropped 

// and will not be part of bcd string.

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

//

EXPORT_C TInt TSatUtility::AsciiToBCD

        ( 

        const TDesC8& aInput, 

        TDes8& aOutput        

        )

    {

    TInt ret( KErrNone );

    TInt i;

    TInt j;

    TInt outLen( 0 );

    TInt length( aInput.Length() );

    aOutput.Zero();

    // Go through the whole string

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

        {

        TUint8 bcd = 0x0F;  // Should never be part of number

        TBool found( EFalse );

        // Search for the ASCII character

        for ( j = 0; ( j < KAsciiBcdTableLength ) && !found; j++ )

            {

            // If the character matches, set the corresponding value

            if ( KAsciiToBCD[j][0] == aInput[i] )

                {

                bcd = KAsciiToBCD[j][1];

                found = ETrue;

                }

            }

        // Add only valid bcd characters...

        if ( found )

            {

            if( aOutput.MaxLength() > aOutput.Length() )

            	{               	

	            // Store to string

	            if ( ( outLen % 2 ) == 0 )

	                {

	                aOutput.Append( bcd );

	                }

	            else

	                {

	                aOutput[outLen / 2] |= ( bcd << 4 );

	                }

            	}

            else

                {

                ret = KErrOverflow;

                }

            outLen++;

            }

        else

            {

            }

        } // For

    // If odd number of digits add endmark

    if ( ( outLen % 2 ) != 0 )

        {

        aOutput[outLen / 2] |= KMaskF0;

        }

    return ret;

    }

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

// TSatUtility::RemoveWildAndExpansionDigit

// Remove Wild 'w' and Expansion digit '.' from EFadn string. Used in SetUpCall 

// proactive command.

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

//

EXPORT_C void TSatUtility::RemoveWildAndExpansionDigit

        (

        const TPtrC8 aString,  

        TDes8& aOutput   

        )

    {

    aOutput.Zero();    

    TUint8 i( 0 );

    TInt maxLength = aOutput.MaxLength();

    TInt length( aString.Length() );

    // Append as many characters as there is room for in the target string

    for ( i = 0; ( i < length ) && ( aOutput.Length() < maxLength ); i++ )

        {

        if ( ( 'w' != aString[i] ) && ( '.' != aString[i] ) )

            {

            aOutput.Append( aString[i] );

            }

        }

    }

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

// TSatUtility::SetAlphaId

// Set Alpha identifier as a Unicode text string and according to the alphabet 

// used

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

//

EXPORT_C void TSatUtility::SetAlphaId				

        ( 

        const TPtrC8 aRawData, 

        TDes& aAlphaId  

        )

    {

    if ( ( KUCS2ArabicCoding == aRawData[0] )

        || ( KUCS2GreekCoding == aRawData[0] )

        || ( KUCS2TurkishCoding == aRawData[0] ) )

        {

        ConvertAlphaFieldsToUnicode( aRawData, aAlphaId );

        }

    else

        {

        // 8-bit 

        TBuf8<RSat::KAlphaIdMaxSize> rawData8;

        rawData8.Copy( aRawData );

        Convert7BitToUnicode16( rawData8, aAlphaId );

        }     

    }

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

// TSatUtility::ConvertToSemiOctet

// Convert integer to BCD format. Only two last digits is used.

// Example TInt 2004 -> 0x40.

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

//

EXPORT_C TUint8 TSatUtility::ConvertToSemiOctet

        ( 

        const TInt aTime  

        )

    {

    // Converting given time to meet the TP-Service-Centre-Time-Stamp format in

    // 3GPP TS 23.040.

    TInt msd( ( aTime / 10 ) % 10 ); // Most significant decimal

    TInt lsd( ( aTime % 10 ) );      // Least significant decimal

    TUint8 ret( TUint8( ( lsd << 4 ) | ( msd ) ) );

    return ret;

    }

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

// TSatUtility::Convert7BitToUnicode16

// Convert a text from GSM 7 bit default alphabet to Unicode format.

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

//

EXPORT_C void TSatUtility::Convert7BitToUnicode16

        (

        const TDesC8& aInput,

        TDes16& aOutput  

        )

    {

    TInt i( 0 );

    aOutput.Zero();

    // Check out which string is the shortest and use its length as a limit

    TInt length ( Min( aInput.Length(), aOutput.MaxLength() ) );

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

        {

        TUint8 character( aInput[i] );

        // This code is an escape to an extension of the 7 bit default alphabet

        // table. 

        if ( 0x1B == character )

            {

            // Extension table

            switch ( aInput[i+1] )

                {

                case 0x28: //{

                    {

                    aOutput.Append( static_cast<TUint16>( 0x7B ) );

                    break;

                    }

                case 0x29: //}

                    {

                    aOutput.Append( static_cast<TUint16>( 0x7D ) );

                    break;

                    }

                case 0x3C: //[

                    {

                    aOutput.Append( static_cast<TUint16>( 0x5B ) );

                    break;

                    }

                case 0x3E: //]

                    {

                    aOutput.Append( static_cast<TUint16>( 0x5D ) );

                    break;

                    }