/*

* Copyright (c) 2004 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:  Implementation of CCbsMessage class.

*

*/

// INCLUDE FILES

#include "CbsServerPanic.h"

#include "CCbsMessage.h"

#include "CbsLogger.h"

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

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

// CCbsMessage::CCbsMessage

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CCbsMessage::CCbsMessage()

    {

    }

// Destructor    

CCbsMessage::~CCbsMessage()

    {

    CBSLOGSTRING("CBSSERVER: >>> CCbsMessage::~CCbsMessage()");

    CBSLOGSTRING("CBSSERVER: <<< CCbsMessage::~CCbsMessage()");

    }

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

// CCbsMessage::Alphabet

// Returns the alphabet set of this message.

// Decides the alphabet set of this message by examining DCS field. 

// Note that DCS value "unspecified" isn't used anymore.

// All messages are considered to have "default" representation.

// (other items were commented in a header).

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

//

TCbsRecAlphabet CCbsMessage::Alphabet() const

    {

    CBSLOGSTRING("CBSSERVER: >>> CCbsMessage::Alphabet()");

    CBSLOGSTRING2("CBSSERVER: CCbsMessage::Alphabet(): iDCS: %d", iDCS );

    TCbsRecAlphabet alphabet( ECbsRecAlphabetUnspecified );   

    // Check for Message preceded by language indication/UCS2 and

    // General Data Coding Indication/UCS2

    if ( 

        ( iDCS & DCS_MASK_LANGUAGE_INDICATION_PRECEDES ) == DCS_MPLI_UCS2 || 

        ( iDCS & DCS_MASK_GENERAL_DATA_CODING_INDICATION ) == DCS_GDCI_UCS2 )

        {

        alphabet = ECbsRecAlphabetUCS2;

        }

    // Check for 8-bit DCSs

    else if ( 

        ( iDCS & DCS_MASK_GENERAL_DATA_CODING_INDICATION ) == DCS_GDCI_8BIT ||

        ( iDCS & DCS_MASK_MESSAGE_HANDLING )== DCS_DCMH_8BIT ||

        ( iDCS & DCS_MASK_UDH ) == DCS_UDH_8BIT )

        {

        alphabet = ECbsRecAlphabet8bit;

        }

     // Else assume that alphabet is default

    else

        {

        alphabet = ECbsRecAlphabetDefault;

        }

    CBSLOGSTRING("CBSSERVER: <<< CCbsMessage::Alphabet(), returning alphabet.");

    return alphabet;

    }

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

// CCbsMessage::AppendContent

// Appends another message's content to this message's content.

// (other items were commented in a header).

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

//

void CCbsMessage::AppendContent( 

    const TDesC& aMsg )

    {

    iMessage->Des().Append( aMsg );

    }

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

// CCbsMessage::AppendContent8

// Appends another message's content to this message's content.

// (other items were commented in a header).

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

//

void CCbsMessage::AppendContent8( 

    const TDesC8& aMsg )

    {

    iMessage8->Des().Append( aMsg );

    }

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

// CCbsMessage::CellId

// Returns identifier of the cell in which the phone was when this  message was received.

// (other items were commented in a header).

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

//  

TUint CCbsMessage::CellId() const

    {

    return iLocationArea.iCellId;

    }

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

// CCbsMessage::Contents

// Returns a pointer descriptor to the Unicode contents of the message.

// (other items were commented in a header).

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

// 

const TDesC& CCbsMessage::Contents() const

    {

    __ASSERT_DEBUG( iMessage != 0, CbsServerPanic( ECbsMsgRepUnprepared ) );

    return *iMessage;

    }

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

// CCbsMessage::Contents8

// Returns a pointer descriptor to 8-bit descriptor representation

// of the message body. 

// (other items were commented in a header).

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

// 

const TDesC8& CCbsMessage::Contents8() const

    {

    __ASSERT_DEBUG( iMessage8 != 0, CbsServerPanic( ECbsMsgRepUnprepared ) );

    return *iMessage8;

    }

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

// CCbsMessage::DCS

// Returns the Data Coding Scheme of this message page.

// Refer to GSM specification 03.38 for details on DCS.

// (other items were commented in a header).

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

// 

TCbsRecDCS CCbsMessage::DCS() const

    {

    return iDCS;

    }

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

// CCbsMessage::GeographicalScope

// Returns the geographical scope of the message.

// This is a 16-bit value containing Geographical 

// Scope (2 bits), Message Code (10 bits) and Update Number (4 bits).

// (other items were commented in a header).

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

//

TCbsRecGeographicalScope CCbsMessage::GeographicalScope() const

    {

    TInt gs( Key() >> 14 );

    if ( gs == KGeographicalScopeCellImmediate || 

         gs == KGeographicalScopeCellNormal )

        {

        return ECbsRecGeographicalScopeCell;

        }

    else if ( gs == KGeographicalScopePLMNNormal ) 

        {

        return ECbsRecGeographicalScopePLMN;

        }

    else

        {

        return ECbsRecGeographicalScopeLAC;

        }

    }

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

// CCbsMessage::GetPLMN

// Returns operator information.

// On return, aNetworkInfo contains identity of the network

// in which the phone was when this message was received.

// (other items were commented in a header).

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

// 

void CCbsMessage::GetPLMN( 

    RMobilePhone::TMobilePhoneNetworkInfoV1& aNetworkInfo ) const

    {

    aNetworkInfo.iCountryCode = iNetworkInfo.iCountryCode;

    aNetworkInfo.iNetworkId = iNetworkInfo.iNetworkId;

    }

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

// CCbsMessage::IsChildSubindex

// Returns boolean value indicating if this message is a child subindex message.

// Child subindex messages have message code 1010101010b and

// (other items were commented in a header).

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

// 

TBool CCbsMessage::IsChildSubindex() const

    {

    return IsIndexMessage() && ( TopicNumber() != 0 );

    }

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

// CCbsMessage::IsClass0

// Returns ETrue, if this message is a Class 0 message according to 

// ETSI GSM specification 03.38.

// Message is of class 0 if the 6th and 7th bit of Geographical Scope

// are both zero.

// (other items were commented in a header).

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

//

TBool CCbsMessage::IsClass0() const

    {

    // Examine bits 0, 1, 4, 6 and 7 of DCS.

    TUint8 class0( DCS() );

    class0 &= DCS_MASK_CLASS0;

    // Check Class 0 indication.

    return class0 == DCS_CLASS0; 

    }

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

// CCbsMessage::IsCompressed

// Returns ETrue, if the message is compressed.

// (other items were commented in a header).

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

//

TBool CCbsMessage::IsCompressed() const

    {

    // The CB message is compressed only if the value of DCS is 011xxxxx.

    return ( TUint8( iDCS >> 5 ) == 3 );

    }

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

// CCbsMessage::IsIndexMessage

// Returns boolean value indicating if this is the index message.  

// Index messages have message code 1010101010b.

// Refer to GSM specifications to for details.

// (other items were commented in a header).

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

// 

TBool CCbsMessage::IsIndexMessage() const

    {

    return MessageCode() == KIndexMessageCode;

    }

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

// CCbsMessage::Key

// Returns the key of the message (serial number).

// (other items were commented in a header).

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

//

TCbsDbMessageKey CCbsMessage::Key() const

    {

    return TCbsDbMessageKey( iSerialNumber );

    }

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

// CCbsMessage::LAC

// Returns location area information.

// (other items were commented in a header).

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

//  

TUint CCbsMessage::LAC() const

    {

    return iLocationArea.iLocationAreaCode;

    }

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

// CCbsMessage::Language

// Returns the language specified in this message.

// (other items were commented in a header).

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

//

TCbsDbLanguage CCbsMessage::Language() const

    {

    __ASSERT_DEBUG( iLanguage != -1, 

        CbsServerPanic( ECbsLanguageNotResolved ) );

    return iLanguage;

    }

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

// CCbsMessage::LanguagePrecedingMessage

// Determines and returns the language of this message

// based on first two characters of message content.

// Assumes that the message content contains language

// indication and that the content has been decoded

// into UCS-2 representation.

// (other items were commented in a header).

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

//

TCbsDbLanguage CCbsMessage::LanguagePrecedingMessage() const

    {

    /// Mapping of ISO639 codes to server internal language representation

    const TCbsIso639ToLangMapElement KLanguageMap[ KNumberOfLanguageMappings ] = 

        {

        TCbsIso639ToLangMapElement( KIso639Danish, ECbsDanish ),

        TCbsIso639ToLangMapElement( KIso639German, ECbsGerman ),

        TCbsIso639ToLangMapElement( KIso639Greek, ECbsGreek ),

        TCbsIso639ToLangMapElement( KIso639English, ECbsEnglish ),

        TCbsIso639ToLangMapElement( KIso639Spanish, ECbsSpanish ),

        TCbsIso639ToLangMapElement( KIso639Finnish, ECbsFinnish ),

        TCbsIso639ToLangMapElement( KIso639French, ECbsFrench ),

        TCbsIso639ToLangMapElement( KIso639Italian, ECbsItalian ),

        TCbsIso639ToLangMapElement( KIso639Dutch, ECbsDutch ),

        TCbsIso639ToLangMapElement( KIso639Norwegian, ECbsNorwegian ),

        TCbsIso639ToLangMapElement( KIso639Portuguese, ECbsPortuguese ),

        TCbsIso639ToLangMapElement( KIso639Swedish, ECbsSwedish ),

        TCbsIso639ToLangMapElement( KIso639Turkish, ECbsTurkish ),

        TCbsIso639ToLangMapElement( KIso639Hungarian, ECbsHungarian ),

        TCbsIso639ToLangMapElement( KIso639Polish, ECbsPolish ),

        TCbsIso639ToLangMapElement( KIso639Czech, ECbsCzech ),

        TCbsIso639ToLangMapElement( KIso639Hebrew, ECbsHebrew ),

        TCbsIso639ToLangMapElement( KIso639Arabic, ECbsArabic ),

        TCbsIso639ToLangMapElement( KIso639Russian, ECbsRussian ),

        TCbsIso639ToLangMapElement( KIso639Icelandic, ECbsIcelandic )

        };

    __ASSERT_DEBUG( iMessage != NULL , CbsServerPanic( ECbsMsgRepUnprepared ) );

    TPtrC isoCode( 

        Contents().Left( KLanguageIndicationLengthWithoutCR ) );

    for ( TInt i( 0 ); i<KNumberOfLanguageMappings; i++ )

        {

        TCbsIso639ToLangMapElement element( KLanguageMap[i] );

        TPtrC code( element.iCode );

        if ( code == isoCode )

            {

            TCbsDbLanguage language( element.iLang );

            return language;

            }

        }

    return ECbsOther;

    }

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

// CCbsMessage::LanguageWithDefaultAlphabet

// Determines and returns the language of this message

// based on DCS value. Assumes that the same DCS value

// indicates, that the language can be determined in this

// way (and not from message content).

// (other items were commented in a header).

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

//

TCbsDbLanguage CCbsMessage::LanguageWithDefaultAlphabet() const

    {

    TCbsDbLanguage language;

    switch ( iDCS )

        {

        // These cases handle DCS values with bits 0000xxxx.

        // All languages use the default alphabet.

        case ECbsRecLanguageGerman: 

            language = ECbsGerman; 

            break;

        case ECbsRecLanguageEnglish: 

            language = ECbsEnglish; 

            break;

        case ECbsRecLanguageItalian: 

            language = ECbsItalian; 

            break;

        case ECbsRecLanguageFrench: 

            language = ECbsFrench; 

            break;

        case ECbsRecLanguageSpanish: 

            language = ECbsSpanish; 

            break;

        case ECbsRecLanguageDutch: 

            language = ECbsDutch; 

            break;

        case ECbsRecLanguageSwedish: 

            language = ECbsSwedish; 

            break;

        case ECbsRecLanguageDanish: 

            language = ECbsDanish; 

            break;

        case ECbsRecLanguagePortuguese: 

            language = ECbsPortuguese; 

            break;

        case ECbsRecLanguageFinnish: 

            language = ECbsFinnish; 

            break;

        case ECbsRecLanguageNorwegian: 

            language = ECbsNorwegian; 

            break;

        case ECbsRecLanguageGreek: 

            language = ECbsGreek; 

            break;

        case ECbsRecLanguageTurkish: 

            language = ECbsTurkish; 

            break;

        case ECbsRecLanguageHungarian: 

            language = ECbsHungarian; 

            break;

        case ECbsRecLanguagePolish: 

            language = ECbsPolish; 

            break;

        case ECbsRecLanguageUnspecified: 

            language = ECbsOther; 

            break;

        case ECbsRecLanguageCzech:

            language = ECbsCzech;

            break;

        case ECbsRecLanguageHebrew:

            language = ECbsHebrew;

            break;

        case ECbsRecLanguageArabic:

            language = ECbsArabic;

            break;

        case ECbsRecLanguageRussian:

            language = ECbsRussian;

            break;

        case ECbsRecLanguageIcelandic:

            language = ECbsIcelandic;

            break;

        default:

            language = ECbsOther;

            break;

        }

    return language;

    }

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

// CCbsMessage::Message

// Returns the 16-bit message content

// (other items were commented in a header).

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

//

HBufC* CCbsMessage::Message() const

    {

    return iMessage;

    }

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

// CCbsMessage::Message8

// Returns the 8-bit representation of the message

// (other items were commented in a header).

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

//

HBufC8* CCbsMessage::Message8() const

    {

    return iMessage8;

    }

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

// CCbsMessage::MessageCode

// Returns the message code of the message.

// (other items were commented in a header).

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

//

TCbsRecMessageCode CCbsMessage::MessageCode() const

    {

    return TCbsRecMessageCode( ( TUint16( Key() & KMessageCodeMask ) ) >> 4 );

    }

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

// CCbsMessage::MessageClass

// Returns the class of the message.

// (other items were commented in a header).

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

//

TInt CCbsMessage::MessageClass() const

    {

	TUint8 msgclass;

	msgclass = TUint8( iDCS >> 4 );

	TInt messageClass( 0 );

    if ( msgclass == 0x05 || msgclass == 0x07 || msgclass == 0x0f ) // 0000 0101 or 0000 0111 or 0000 1111

		{

			msgclass = 0x03; // 0000 0011

			// Lets find out last two bits

			msgclass = TUint8( msgclass & iDCS );

			switch ( msgclass )

			{

				case 1:

					messageClass = 1;

					break;

				case 2:

					messageClass = 2;

					break;

				case 3:

					messageClass = 3;

					break;

				case 0:

				default:

					messageClass = 0;

					break;

			}

		}

	return messageClass;

    }

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

// CCbsMessage::MessagePrecededByLanguageIndication

// Returns ECbsRecLanguageIndicationBody if message's content is preceded 

// by language indication (see GSM 03.38).

// (other items were commented in a header).

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

//

TCbsRecLanguageIndication CCbsMessage::MessagePrecededByLanguageIndication() const

    {

    TCbsRecLanguageIndication indication( ECbsRecLanguageIndicationHeader );

    if ( iDCS == 0x10 || iDCS == 0x11 )

        {

        indication = ECbsRecLanguageIndicationBody;

        }

    return indication;

    }

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

// CCbsMessage::NetworkMode

// Returns current network mode (GSM/WCDMA)

// 

// (other items were commented in a header).

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

//

TCbsNetworkMode CCbsMessage::NetworkMode() const

    {

    return iNetworkMode;