/*
* Copyright (c) 2003 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 CCbsRecDecoder class 
*                member functions.
*    
*                CCCbsRecDecoder handles decoding of message contents.
*
*                CbsServer receives messages stored in 8-bit descriptors
*                from ETel. This class converts them into 16-bit descriptors
*                and decodes the message representation into UCS-2 (which
*                is used by Symbian OS internally). 
*
*/


// INCLUDE FILES

#include <e32svr.h>
#include <charconv.h>
#include "CbsServerConstants.h"
#include "CCbsRecDecoder.h"
#include "CCbsMessage.h"
#include "CCbsRecMessage.h"
#include "CCbsRecWcdmaMessage.h"
#include "CbsLogger.h"

// CONSTANTS

// Max characters in generated unicode 
const TInt KMaxCharsInGeneratedUnicode = 128;   

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

// -----------------------------------------------------------------------------
// CCbsMcnSession::CCbsMcnSession
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CCbsRecDecoder::CCbsRecDecoder()
    {
    }

// -----------------------------------------------------------------------------
// CCbsRecDecoder::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CCbsRecDecoder::ConstructL()
    {
    iConverter = CCnvCharacterSetConverter::NewL();
    User::LeaveIfError( iFs.Connect() );
    }     

// -----------------------------------------------------------------------------
// CCbsRecDecoder::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CCbsRecDecoder* CCbsRecDecoder::NewL()
    {
    CCbsRecDecoder* self = new(ELeave) CCbsRecDecoder;
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop();
    return self;
    }
    
// Destructor
CCbsRecDecoder::~CCbsRecDecoder()
    {
    CBSLOGSTRING("CBSSERVER: >>> CCbsRecDecoder::~CCbsRecDecoder()");    
    iFs.Close();
    delete iConverter;
    CBSLOGSTRING("CBSSERVER: <<< CCbsRecDecoder::~CCbsRecDecoder()");
    }

// -----------------------------------------------------------------------------
// CCbsRecDecoder::DecodeL
// Decodes 7-bit, 8-bit and 16-bit representations into UCS-2.
// If the message has a language indication prefixed
// in the message body, the indication is removed.
// Compressed messages are not supported.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsRecDecoder::DecodeL( 
    CCbsMessage& aMessage )
    {
    if ( aMessage.IsCompressed() )
        {
        User::Leave( KErrNotSupported );
        }

    // Convert message into plaintext.
    DoDecodeL( aMessage );

    // 8-bit representation not needed anymore.
    aMessage.ReleaseEightBitRepresentation();

    // Determine language of this message (from header or content),
    aMessage.ResolveLanguage();

    // Remove language indication, if present, from message.
    aMessage.RemoveLanguageIndicationFromBodyL();
    }

// -----------------------------------------------------------------------------
// CCbsRecDecoder::DoDecodeL
// Decodes the given message's content. 
// Decodes aMessage's 7-bit/Unicode representation
// into internal Unicode representation.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsRecDecoder::DoDecodeL( 
    CCbsMessage& aMessage )
    {
    CBSLOGSTRING("CBSSERVER: >>> CCbsRecDecoder::DoDecodeL()");
    
    TCbsRecAlphabet alphabet( aMessage.Alphabet() );
    if ( alphabet == ECbsRecAlphabetDefault || 
         alphabet == ECbsRecAlphabetUnspecified )
        {
        DefaultAlphabetDecodeL( aMessage );
        }
    else if ( alphabet == ECbsRecAlphabet8bit )
        {
        EightbitAlphabetDecodeL( aMessage );
        }
    else
        {
        UnicodeDecodeL( aMessage );
        }
    CBSLOGSTRING("CBSSERVER: <<< CCbsRecDecoder::DoDecodeL()");
    }
    
// -----------------------------------------------------------------------------
// CCbsRecDecoder::UnicodeDecodeL
// Decodes 8-bit and Unicode message representations.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsRecDecoder::UnicodeDecodeL( 
    CCbsMessage& aMsg )
    {
    CBSLOGSTRING("CBSSERVER: >>> CCbsRecDecoder::UnicodeDecodeL()");
    
    TPtrC8 contents( aMsg.Contents8() );

    // Reserve enough space for the actual contents plus
    // the CR key
    aMsg.ReserveContentSizeL( contents.Length()+1 );

    // Check if the message is preceded with language.
    if( aMsg.DCS() == DCS_MPLI_UCS2 )
        {
        // The language is encoded as 7-bit USSD. Unpack that
        // and add CR after the language to match the default
        // alphabet case.
        TBuf<3> language;
        language.Copy( contents.Left(2) );
        language[1] <<= 1;
        language[1] |= (language[0] & 0x80) >> 7;
        language[0] &= 0x7f;
        language.Append( EKeyEnter );
        aMsg.AppendContent( language );

        // Skip the language indication
        contents.Set( contents.Mid(2) );
        }

    // The rest of the message is UCS2 encoded Unicode. 
    // Make sure the byte order is correct.
    HBufC* text = HBufC::NewL( contents.Length() / 2 );
    CleanupStack::PushL( text );

    TPtr ptr( text->Des() );
    TInt length( contents.Length() );

    // If the length is an odd number, remove the last character.
    if ( length & 0x01 )
        {
        length -= 1;
        }

    for ( TInt i( 0 ); i < length; i += 2 )
        {
        ptr.Append( ( contents[ i ] << 8 ) + contents[ i + 1 ] );
        }

    aMsg.AppendContent( RemoveTrailingCR( *text ) );
    CleanupStack::PopAndDestroy();
    
    CBSLOGSTRING("CBSSERVER: <<< CCbsRecDecoder::UnicodeDecodeL()");
    }
   
// -----------------------------------------------------------------------------
// CCbsRecDecoder::DefaultAlphabetDecodeL
// Decodes 7-bit message representation.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsRecDecoder::DefaultAlphabetDecodeL( 
    CCbsMessage& aMsg )
    {
    CBSLOGSTRING("CBSSERVER: >>> CCbsRecDecoder::DefaultAlphabetDecodeL()");
    
    // Check that the converter is available
    CCnvCharacterSetConverter* characterSetConverter = 
        CCnvCharacterSetConverter::NewLC(); // on CS

    CCnvCharacterSetConverter::TAvailability availability = 
        characterSetConverter->PrepareToConvertToOrFromL(
            KCharacterSetIdentifierSms7Bit, iFs );

    if ( availability == CCnvCharacterSetConverter::ENotAvailable )
        {
        User::Leave( KErrNotFound );
        }

    // Allocate a buffer for the cleartext message
    TBuf8< KCbsMaxCharsInPage + 1 > realMsg;

    // Get a pointer to the encoded message
    TPtrC8 msgPartOfEtelMsg = aMsg.Contents8();

    // Length of the cleartext message.
    TInt messageLength( ( msgPartOfEtelMsg.Length() * 8 ) / 7 );

    static const TUint mask_table[ 8 ] = 
			    { 0x7F, 0x01,0x03,0x07,0x0F,0x1F,0x3F,0x7F };
    TUint8  si,di;            // Indexes
    TInt  tmp_modulo;         // Temporary; to improve efficiency
    si = 0;

    // The location of the current 7-bit character determines the
    // action to be taken. Only every 7th character is not divided into
    // two bytes. All other characters will have to be contructed by
    // combining bits of two consequent bytes.

    for ( di = 0; di < messageLength; di++ )
	    {
	    TUint num2 = 0;
	    tmp_modulo = di % 8;
	    switch ( tmp_modulo )
	        {
	        case 0:
		        num2 = msgPartOfEtelMsg[ si ] & 0x7F;
		        realMsg.Append( num2 );
		        break;
	        case 7:
		        num2 = ( msgPartOfEtelMsg[ si ] >> 1 ) & 0x7F;
		        realMsg.Append( num2 );
		        si++;
		        break;
	        default:
	            num2 = msgPartOfEtelMsg[ si ] >> ( 8 - ( tmp_modulo ) );
	            num2 &= mask_table[ tmp_modulo ];
	            num2 |= msgPartOfEtelMsg[ si + 1 ] << ( tmp_modulo );
	            num2 &= 0x7F;
	            realMsg.Append( num2 );
	            si++;
	        break;
	        }//switch( tmp_modulo )
	    }//for

    TBuf16<KMaxCharsInGeneratedUnicode> generatedUnicode;
    TInt state( CCnvCharacterSetConverter::KStateDefault ); // has to be ref.
    
    // Remove all trailing control characters from the end of the Cell info msg
    TBuf8<KCbsMaxCharsInPage> cleanedMsg;
    if ( aMsg.TopicNumber() == KCellInfoTopic )
        {
        cleanedMsg = RemoveTrailingControlChars( realMsg );
        User::LeaveIfError( characterSetConverter->ConvertToUnicode(
            generatedUnicode, cleanedMsg, state ) );
        }
    else
        {
        User::LeaveIfError( characterSetConverter->ConvertToUnicode(
            generatedUnicode, realMsg, state ) );
        } 
    
    CleanupStack::PopAndDestroy(); // characterSetConverter
    
    aMsg.ReserveContentSizeL( messageLength );
    aMsg.AppendContent( RemoveTrailingCR( generatedUnicode ) );
    
    CBSLOGSTRING("CBSSERVER: <<< CCbsRecDecoder::DefaultAlphabetDecodeL()");
    }
    
// -----------------------------------------------------------------------------
// CCbsRecDecoder::EightbitAlphabetDecodeL
// Decodes 8-bit message representation.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsRecDecoder::EightbitAlphabetDecodeL( 
    CCbsMessage& aMsg )
    {
    CBSLOGSTRING("CBSSERVER: >>> CCbsRecDecoder::EightbitAlphabetDecodeL()");
    
    // Copy 8-bit representation to 16-bit
    HBufC* hbuf = HBufC::NewL( aMsg.Contents8().Length() );
    CleanupStack::PushL( hbuf );
    
    TPtr16 ptr16 = hbuf->Des();     
    ptr16.Copy( aMsg.Contents8() );        
    
    // Reserve enough space for the actual contents    
    aMsg.ReserveContentSizeL( aMsg.Contents8().Length() );  
    aMsg.AppendContent( RemoveTrailingCR( *hbuf ) );
    
    CleanupStack::PopAndDestroy( hbuf );
    
    CBSLOGSTRING("CBSSERVER: <<< CCbsRecDecoder::EightbitAlphabetDecodeL()");
    }

// -----------------------------------------------------------------------------
// CCbsRecDecoder::RemoveTrailingCR
// Removes the trailing CRs from a message.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TPtrC CCbsRecDecoder::RemoveTrailingCR( 
    const TDesC& aText )
    {
    TInt i( aText.Length() );
    for ( ; i > 0 && aText[ i - 1 ] == EKeyEnter; i-- )
        {
        // nothing
        }

    return aText.Left( i );
    }
    
// -----------------------------------------------------------------------------
// CCbsRecDecoder::RemoveTrailingControlChars
// Removes the trailing control characters from a message.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TPtrC8 CCbsRecDecoder::RemoveTrailingControlChars( 
    const TDesC8& aText )
    {
    TInt i( aText.Length() );
    for ( ; i > 0 && ( aText[ i - 1 ] == EKeyEnter || aText[ i - 1 ] == EKeyLineFeed ); i-- )
        {
        // nothing
        }

    return aText.Left( i );
    }

// ========================== OTHER EXPORTED FUNCTIONS =========================
//  End of File