/*

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

#include "isimessagetrace.h"

#include <pn_const.h>

#ifdef OST_TRACE_COMPILER_IN_USE

#endif

//  LOCAL CONSTANTS AND MACROS  

const TInt KMessageHeaderLength ( 6 );

const TUint16 KSixteenBitZero ( 0x0000 );

const TUint32 KThirtytwoBitZero ( 0x00000000 );

const TInt KMinSbLength ( 4 );

const TUint8 KPaddingByte ( 0x00 );

#define IS_DEV_HOST( dev )            ( ( dev & 0xF0 ) == 0 )

#define GET_RECEIVER_DEV( msg )       ( msg[ ISI_HEADER_OFFSET_RECEIVERDEVICE ] & 0xFC )

#define GET_SENDER_DEV( msg )         ( msg[ ISI_HEADER_OFFSET_SENDERDEVICE ] & 0xFC )

#define GET_RECEIVER_OBJ( msg )       IS_DEV_HOST( msg[ ISI_HEADER_OFFSET_RECEIVERDEVICE ] ) ? \

                                      ( ( TUint16 )msg[ ISI_HEADER_OFFSET_RECEIVEROBJECT ] + ( ( msg [ ISI_HEADER_OFFSET_RECEIVERDEVICE ] & 0x0F ) << 8 ) ) : \

                                      ( ( TUint16 )msg[ ISI_HEADER_OFFSET_RECEIVEROBJECT ] + ( ( msg [ ISI_HEADER_OFFSET_RECEIVERDEVICE ] & 0x03 ) << 8 ) )

#define GET_SENDER_OBJ( msg )         IS_DEV_HOST( msg[ ISI_HEADER_OFFSET_SENDERDEVICE ] ) ? \

                                      ( ( TUint16 )msg[ ISI_HEADER_OFFSET_SENDEROBJECT ] + ( ( msg[ ISI_HEADER_OFFSET_SENDERDEVICE ] & 0x0F ) << 8 ) ) : \

                                      ( ( TUint16 )msg[ ISI_HEADER_OFFSET_SENDEROBJECT ] + ( ( msg[ ISI_HEADER_OFFSET_SENDERDEVICE ] & 0x03 ) << 8 ) )

#define SET_RECEIVER_DEV( msg, dev )  ( msg[ ISI_HEADER_OFFSET_RECEIVERDEVICE] = ( ( msg[ ISI_HEADER_OFFSET_RECEIVERDEVICE ] & 0x03 ) | ( ( dev ) & 0xFC ) ) )

#define SET_SENDER_DEV( msg, dev )    ( msg[ ISI_HEADER_OFFSET_SENDERDEVICE] = ( ( msg[ ISI_HEADER_OFFSET_SENDERDEVICE ] & 0x03 ) | ( ( dev ) & 0xFC ) ) )

#define SET_RECEIVER_OBJ( msg, o )    msg[ ISI_HEADER_OFFSET_RECEIVERDEVICE ] = ( IS_DEV_HOST( msg[ ISI_HEADER_OFFSET_RECEIVERDEVICE ] ) ) ? \

                                      GET_RECEIVER_DEV( msg ) | ( ( ( o ) >> 8 ) & 0x0F ) : GET_RECEIVER_DEV( msg ) | ( ( ( o ) >> 8 ) & 0x03 ), \

                                      msg[ ISI_HEADER_OFFSET_RECEIVEROBJECT ] = ( TUint8 )( ( o ) & 0x00FF )

#define SET_SENDER_OBJ( msg, o )      msg[ ISI_HEADER_OFFSET_SENDERDEVICE ] = ( IS_DEV_HOST( msg[ ISI_HEADER_OFFSET_SENDERDEVICE ] ) ) ? \

                                      GET_SENDER_DEV( msg ) | ( ( ( o ) >> 8 ) & 0x0F ) : GET_SENDER_DEV( msg ) | ( ( ( o ) >> 8 ) & 0x03 ), \

                                      msg[ ISI_HEADER_OFFSET_SENDEROBJECT ] = ( TUint8 )( ( o ) & 0x00FF )

// Panic code literals

_LIT( KInvalidOffset, "IsiMessage: OFFSET Invalid" );

_LIT( KInvalidValue, "IsiMessage: Invalid Value" );

_LIT( KInvalidSubBlockType, "IsiMessage: SBTYPE Invalid");

_LIT( KInvalidResourceId, "IsiMessage: Invalid ExtendedResourceId");

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

// TIsi::operator=

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

EXPORT_C TIsi& TIsi::operator=

        ( 

        const TIsi&

        )

    {

    C_TRACE( ( _T( "TIsi::operator=" ) ) );

    OstTrace0( TRACE_NORMAL, TISI_OPERATOR, "TIsi::operator=" );

    return ( *this );

    }

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

// TIsiReceiveC::FindSubBlockOffsetById

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

EXPORT_C TInt TIsiReceiveC::FindSubBlockOffsetById 

        ( 

        const TUint aSbStartOffset,

        const TUint aSubblockId,

        const TSubBlockType aType,

        TUint &aSubBlockOffset

        ) const

    {

    C_TRACE( ( _L ( "TIsiReceiveC::FindSubblockOffsetById entering, (sbStart 0x%x, sbId 0x%x, aType %d  )" ), aSbStartOffset, aSubblockId, aType ) );

    OstTraceExt3( TRACE_NORMAL, TISIRECEIVEC_FINDSUBBLOCKOFFSETBYID, "TIsiReceiveC::FindSubBlockOffsetById entering;sbStart=%u;sbId=%u;aType=%x;", aSbStartOffset, aSubblockId, ( TUint )&( aType ));   

    TInt finder_offset( aSbStartOffset );

    TInt length( iBuffer.Length() );

    // Message has to be divisible by four, when it has any subblocks

    TRACE_ASSERT ( length %  4 == 0 ); //Invalid length

    TRACE_ASSERT ( finder_offset % 4 == 0 ); //Invalid offset

    TUint subblock_id( 0 );

    TUint subblock_len( 0 );

    TBool found( EFalse );

    TInt retval( KErrNotFound );

    if( ( length - KMinSbLength ) < finder_offset )

        {

            C_TRACE( ( _L ( "TIsiReceiveC::FindSubblockOffsetById used with msg which doesn't contains any subblocks, (retval %d)" ), retval ) );

            OstTrace1( TRACE_NORMAL, DUP1_TISIRECEIVEC_FINDSUBBLOCKOFFSETBYID, "TIsiReceiveC::FindSubBlockOffsetById used with msg which doesn't contains any subblocks;retval=%d", retval );

        }

    else

        {        

        do

            {

            switch( aType )

                {

                case EIsiSubBlockTypeId8Len8:

                   {

                  subblock_id = this->Get8bit( finder_offset );

                  subblock_len = this->Get8bit( finder_offset + 1 );

                  break;

                  }

                case EIsiSubBlockTypeId8Len16:

                    {

                    subblock_id = this->Get8bit( finder_offset );

                    subblock_len = this->Get16bit( finder_offset + 2 );

                    break;

                    }

                case EIsiSubBlockTypeId16Len8:

                    {

                    subblock_id = this->Get16bit( finder_offset );

                    subblock_len = this->Get8bit( finder_offset + 2 );

                    break;

                    }

                case EIsiSubBlockTypeId16Len16:

                    {

                    subblock_id = this->Get16bit( finder_offset );

                    subblock_len = this->Get16bit( finder_offset + 2 );

                    break;

                    }

                case EIsiSubBlockTypeId8Len32:

                    {

                    subblock_id = this->Get8bit( finder_offset );

                    subblock_len = this->Get32bit( finder_offset + 4 );

                    break;

                    }

                default:

                    {

                    User::Panic( KInvalidSubBlockType, KErrArgument );

                    break;

                    }

                }

            if ( subblock_len == 0 )

                {

                C_TRACE( ( _L ( "TIsiReceiveC::FindSubblockOffsetById has found corrupted data, sb_len = 0 ->stop searching!" ) ) );           

                OstTrace0( TRACE_NORMAL, DUP2_TISIRECEIVEC_FINDSUBBLOCKOFFSETBYID, "TIsiReceiveC::FindSubBlockOffsetById has found corrupted data, sb_len = 0 ->stop searching!" );

                found = ETrue;

                retval = KErrNotFound;

                }

            if ( aSubblockId == subblock_id )

                {

                found = ETrue;

                aSubBlockOffset = finder_offset;

                retval = KErrNone;

                }

            else

                {

                finder_offset+= subblock_len;

                }

            } while ( !found && ( finder_offset + KMinSbLength <= length ) );

        }

    C_TRACE( ( _L ( "TIsiReceiveC::FindSubblockOffsetById returning, aSbStartOffset = 0x%x" ), finder_offset ) );

    OstTrace1( TRACE_NORMAL, DUP3_TISIRECEIVEC_FINDSUBBLOCKOFFSETBYID, "TIsiReceiveC::FindSubBlockOffsetById - return found sbStartOffset=%d", finder_offset );   

    return retval;

    }

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

// TIsiReceiveC::FindSubBlockOffsetByIndex

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

EXPORT_C TInt TIsiReceiveC::FindSubBlockOffsetByIndex

        ( 

        const TUint aSbStartOffset,

        const TUint aSubblockIndex,

        const TSubBlockType aType,

        TUint &aSubBlockOffset

        ) const

    { 

    C_TRACE( ( _L ( "TIsiReceiveC::FindSubblockOffsetByIndex entering, (sbStart 0x%x, sbIndex 0x%x, aType %d  )" ), aSbStartOffset, aSubblockIndex, aType ) );

    OstTraceExt3( TRACE_NORMAL, TISIRECEIVEC_FINDSUBBLOCKOFFSETBYINDEX, "TIsiReceiveC::FindSubBlockOffsetByIndex;sbStart=%u;subblockIndex=%u;aType=%x;", aSbStartOffset, aSubblockIndex, ( TUint )&( aType ) );

    TInt finder_offset( aSbStartOffset );

    TInt length( iBuffer.Length() );

    // Message has to be divisible by four, when it has any subblocks

    TRACE_ASSERT ( length % 4 == 0 ); //Invalid length

    TRACE_ASSERT ( finder_offset % 4 == 0 ); // Invalid offset

    TUint subblock_len ( 0 );

    TUint index ( 0 );

    TBool found ( EFalse );

    TInt retval( KErrNotFound );

    if( ( length - KMinSbLength ) < finder_offset )

        {

        C_TRACE( ( _L ( "TIsiReceiveC::FindSubblockOffsetByIndex used with msg which doesn't contains any subblocks, (retval %d)" ), retval ) );     

        OstTrace1( TRACE_NORMAL, DUP1_TISIRECEIVEC_FINDSUBBLOCKOFFSETBYINDEX, "TIsiReceiveC::FindSubBlockOffsetByIndex used with msg which doesn't contains any subblocks;retval=%d", retval );

        }

    else

        {        

        do

            {

            index++;

            switch( aType )

            {

            case EIsiSubBlockTypeId8Len8:

                {

                subblock_len = this->Get8bit( finder_offset + 1 );

                break;

                }

            case EIsiSubBlockTypeId8Len16:

                {

                subblock_len = this->Get16bit( finder_offset + 2 );

                break;

                }

            case EIsiSubBlockTypeId16Len8:

                {

                subblock_len = this->Get8bit( finder_offset + 2 );

                break;

                }

            case EIsiSubBlockTypeId16Len16:

                {

                subblock_len = this->Get16bit( finder_offset + 2 );

                break;

                }

            case EIsiSubBlockTypeId8Len32:

                {

                subblock_len = this->Get32bit( finder_offset + 4 );

                break;

                }

            default:

                {

                User::Panic( KInvalidSubBlockType, KErrArgument );

                break;

                }

            }

        if ( subblock_len == 0 )

            {

            C_TRACE( ( _L ( "TIsiReceiveC::FindSubblockOffsetByIndex has found corrupted data, sb_len = 0 ->stop searching" ) ) );           

            OstTrace0( TRACE_NORMAL, DUP2_TISIRECEIVEC_FINDSUBBLOCKOFFSETBYINDEX, "TIsiReceiveC::FindSubBlockOffsetByIndex has found corrupted data, sb_len = 0 ->stop searching!" );

            found = ETrue;

            retval = KErrNotFound;

            }

        if( index == aSubblockIndex )

            {

            found = ETrue;

            aSubBlockOffset = finder_offset;

            retval = KErrNone;

            }

        else

            {

            finder_offset+=subblock_len;

            }

        } while( !found && ( index <= aSubblockIndex ) && (finder_offset + KMinSbLength <= length ) );

    }

    C_TRACE( ( _L ( "TIsiReceiveC::FindSubblockOffsetByIndex returning, aSbStartOffset = 0x%x" ), finder_offset ) );

    OstTrace1( TRACE_NORMAL, DUP3_TISIRECEIVEC_FINDSUBBLOCKOFFSETBYINDEX, "TIsiReceiveC::FindSubBlockOffsetByIndex - return found sbStartOffset=%d", finder_offset );

    return retval;

    }

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

// TIsiReceiveC::Get16bit

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

EXPORT_C TUint16 TIsiReceiveC::Get16bit

        (

        const TUint aOffset 

        ) const

    {

    C_TRACE( ( _L ( "TIsiReceiveC::Get16bit entering, aOffset 0x%x" ), aOffset ) );

    OstTrace1( TRACE_NORMAL, TISIRECEIVEC_GET16BIT, "TIsiReceiveC::Get16bit - enter;aOffset=%u", aOffset );

    ASSERT_RESET_ALWAYS( ((iBuffer.Length() - 1) > aOffset), KInvalidOffset, KErrOverflow );

    TRACE_ASSERT ( aOffset % 2 == 0 ); //Invalid offset

    TUint16 retval( KSixteenBitZero );

    TUint16 byte1( KSixteenBitZero );

    TUint16 byte2( KSixteenBitZero );

    byte1 = iBuffer[ aOffset ];

    byte2 = iBuffer[ aOffset + 1 ];

    retval = TUint16( ( byte1 << 8 ) | byte2 );  

    C_TRACE( ( _L ( "TIsiReceiveC::Get16bit - return, return 16bit value = 0x%x" ), retval ) );

   OstTraceExt1( TRACE_NORMAL, DUP1_TISIRECEIVEC_GET16BIT, "TIsiReceiveC::Get16bit - return retval=%hu", retval );

    return retval;

    }

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

// TIsiReceiveC::Get32bit

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

EXPORT_C TUint32 TIsiReceiveC::Get32bit

        (

        const TUint aOffset

        ) const

    {

    C_TRACE( ( _L ( "TIsiReceiveC::Get32bit entering, aOffset = 0x%x" ) , aOffset ) );

    OstTrace1( TRACE_NORMAL, TISIRECEIVEC_GET32BIT, "TIsiReceiveC::Get32bit - enter;aOffset=%u", aOffset );

    ASSERT_RESET_ALWAYS( ( iBuffer.Length() - 3 > aOffset ), KInvalidOffset, KErrOverflow );

    TRACE_ASSERT ( aOffset % 4 == 0 ); // Invalid offset

    TUint32 retval( KThirtytwoBitZero );

    TUint32 byte1( KThirtytwoBitZero );

    TUint32 byte2( KThirtytwoBitZero );

    TUint32 byte3( KThirtytwoBitZero );

    TUint32 byte4( KThirtytwoBitZero );

    byte1 = iBuffer[ aOffset ];

    byte2 = iBuffer[ aOffset + 1 ];

    byte3 = iBuffer[ aOffset + 2 ];

    byte4 = iBuffer[ aOffset + 3 ];

    retval = TUint32( byte1 << 24 );

    retval = TUint32( retval | ( byte2 << 16 ));

    retval = TUint32( retval | ( byte3 << 8 ));

    retval = TUint32( retval | byte4 );

    C_TRACE( ( _L ( "TIsiReceiveC::Get32bit - return, Return 32bit value = 0x%x" ), retval ) );

    OstTrace1( TRACE_NORMAL, DUP1_TISIRECEIVEC_GET32BIT, "TIsiReceiveC::Get32bit - return retval=%d", retval );

    return retval;

    }

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

// TIsiReceiveC::Get8bit

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

EXPORT_C TUint8 TIsiReceiveC::Get8bit

        (

        const TUint aOffset 

        ) const

    {

    C_TRACE( ( _L ( "TIsiReceiveC::Get8bit entering, aOffset = 0x%x" ) , aOffset ) );

    OstTrace1( TRACE_NORMAL, TISIRECEIVEC_GET8BIT, "TIsiReceiveC::Get8bit - enter;aOffset=%u", aOffset );

    ASSERT_RESET_ALWAYS( ( iBuffer.Length() > aOffset ), KInvalidOffset, KErrOverflow );

    C_TRACE( ( _L ( "TIsiReceiveC::Get8bit - return, return value = 0x%x" ) , iBuffer[aOffset] ) );

    OstTraceExt1( TRACE_NORMAL, DUP1_TISIRECEIVEC_GET8BIT, "TIsiReceiveC::Get8bit - return iBuffer[aOffset]=%hhu", iBuffer[aOffset] );

    return iBuffer[ aOffset ];

    }

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

// TIsiReceiveC::GetData

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

EXPORT_C const TPtrC8 TIsiReceiveC::GetData

        (

        const TUint aOffset,

        const TInt aLength

        ) const

    {

    C_TRACE( ( _L ( "TIsiReceiveC::GetData entering, aOffset = 0x%x" ), aOffset ) );

    OstTrace1( TRACE_NORMAL, TISIRECEIVEC_GETDATA, "TIsiReceiveC::GetData - enter;aOffset=%u", aOffset );

    ASSERT_RESET_ALWAYS( ( ( iBuffer.Length() - aLength ) >= aOffset), KInvalidOffset, KErrOverflow );

    ASSERT_RESET_ALWAYS( ( iBuffer.Length() >= aLength ), KInvalidOffset, KErrOverflow );

    TRACE_ASSERT ( aLength > 0 ); // Invalid length, should be >0

    C_TRACE( ( _L ( "TIsiReceiveC::GetData - return, aOffset = 0x%x, aLength = 0x%x" ), aOffset, aLength ) );

    OstTraceExt2( TRACE_NORMAL, DUP1_TISIRECEIVEC_GETDATA, "TIsiReceiveC::GetData - return aOffset=%u;aLength=%u", aOffset, aLength );

    return TPtrC8( iBuffer.Mid( aOffset, aLength ) );

    }

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

// TIsiReceiveC::TIsiReceiveC

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

EXPORT_C TIsiReceiveC::TIsiReceiveC

        (

        const TDesC8& aBuf

        )

        :TIsi(),

        iBuffer( aBuf )

    {

    C_TRACE( ( _T ( "TIsiReceiveC::TIsiReceiveC constructor" ) ) );

    OstTrace0( TRACE_NORMAL, TISIRECEIVEC_TISIRECEIVEC, "TIsiReceiveC::TIsiReceiveC constructor" );

    }

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

// TIsiReceiveC::GetBuffer

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

EXPORT_C const TPtrC8 TIsiReceiveC::GetBuffer

        () const

    {

    C_TRACE( ( _T ( "TIsiReceiveC::GetBuffer" ) ) );

    OstTrace0( TRACE_NORMAL, TISIRECEIVEC_GETBUFFER, "TIsiReceiveC::GetBuffer" );

    return iBuffer;

    }

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

// TIsiReceiveC::GetReceiverDevice

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

EXPORT_C TUint8 TIsiReceiveC::GetReceiverDevice

        () const

    {

    C_TRACE( ( _T ( "TIsiReceiveC::GetReceiverDevice - entering" ) ) );

    OstTrace0( TRACE_NORMAL, TISIRECEIVEC_GETRECEIVERDEVICE, "TIsiReceiveC::GetReceiverDevice - enter" );

    ASSERT_RESET_ALWAYS( (iBuffer.Length() > ISI_HEADER_OFFSET_MESSAGEID), KInvalidOffset, KErrOverflow);

    TUint8 receiverDevice = GET_RECEIVER_DEV(iBuffer);

    C_TRACE( ( _T ( "TIsiReceiveC::GetReceiverDevice - return, receiverDevice = 0x%x" ), receiverDevice ) );

    OstTraceExt1( TRACE_NORMAL, DUP1_TISIRECEIVEC_GETRECEIVERDEVICE, "TIsiReceiveC::GetReceiverDevice - return receiverDevice=%hhu", receiverDevice );

    return receiverDevice;

    }

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

// TIsiReceiveC::GetSenderDevice

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

EXPORT_C TUint8 TIsiReceiveC::GetSenderDevice

        () const

    {

    C_TRACE( ( _T ( "TIsiReceiveC::GetSenderDevice - entering" ) ) );

    OstTrace0( TRACE_NORMAL, TISIRECEIVEC_GETSENDERDEVICE, "TIsiReceiveC::GetSenderDevice - enter" );

    ASSERT_RESET_ALWAYS( (iBuffer.Length() > ISI_HEADER_OFFSET_MESSAGEID), KInvalidOffset, KErrOverflow );

    TUint8 senderDevice = GET_SENDER_DEV(iBuffer);

    C_TRACE( ( _T ( "TIsiReceiveC::GetSenderDevice - return, senderDevice = 0x%x" ), senderDevice ) );

    OstTraceExt1( TRACE_NORMAL, DUP1_TISIRECEIVEC_GETSENDERDEVICE, "TIsiReceiveC::GetSenderDevice - return senderDevice=%hhu", senderDevice );

    return senderDevice;

    }

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

// TIsiReceiveC::GetReceiverObject

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

EXPORT_C TUint16 TIsiReceiveC::GetReceiverObject

        () const

    {

    C_TRACE( ( _T ( "TIsiReceiveC::GetReceiverObject - entering" ) ) );

    OstTrace0( TRACE_NORMAL, TISIRECEIVEC_GETRECEIVEROBJECT, "TIsiReceiveC::GetReceiverObject - enter" );

    ASSERT_RESET_ALWAYS( (iBuffer.Length() > ISI_HEADER_OFFSET_MESSAGEID), KInvalidOffset, KErrOverflow );

    TUint16 receiverObject = static_cast<TUint16>GET_RECEIVER_OBJ(iBuffer);

    C_TRACE( ( _T ( "TIsiReceiveC::GetReceiverObject - return, receiverObject = 0x%x" ), receiverObject ) );

    OstTraceExt1( TRACE_NORMAL, DUP1_TISIRECEIVEC_GETRECEIVEROBJECT, "TIsiReceiveC::GetReceiverObject - return receiverObject=%hu", receiverObject );

    return receiverObject;

    }

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

// TIsiReceiveC::GetSenderObject

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

EXPORT_C TUint16 TIsiReceiveC::GetSenderObject

        () const

    {

    C_TRACE( ( _T ( "TIsiReceiveC::GetSenderObject - entering" ) ) );

    OstTrace0( TRACE_NORMAL, TISIRECEIVEC_GETSENDEROBJECT, "TIsiReceiveC::GetSenderObject - enter" );

    ASSERT_RESET_ALWAYS( (iBuffer.Length() > ISI_HEADER_OFFSET_MESSAGEID),  KInvalidOffset, KErrOverflow );

    TUint16 senderObject = static_cast<TUint16>GET_SENDER_OBJ( iBuffer );

    C_TRACE( ( _T ( "TIsiReceiveC::GetSenderObject - return, senderObject = 0x%x" ), senderObject ) );

    OstTraceExt1( TRACE_NORMAL, DUP1_TISIRECEIVEC_GETSENDEROBJECT, "TIsiReceiveC::GetSenderObject - return senderObject=%hu", senderObject );

    return senderObject;

    }

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

// TIsiReceiveC::GetExtendedResourceId

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

EXPORT_C TUint32 TIsiReceiveC::GetExtendedResourceId

        () const

    {

    C_TRACE( ( _T ( "TIsiReceiveC::GetExtendedResourceId - entering" ) ) );

    OstTrace0( TRACE_NORMAL, TISIRECEIVEC_GETEXTENDEDRESOURCEID, "TIsiReceiveC::GetExtendedResourceId - enter" );

    TUint32 extendedResourceId(0x00000000);

    //Check that extended resource id available and not reading over the buffer

    ASSERT_RESET_ALWAYS( (iBuffer[ISI_HEADER_OFFSET_RESOURCEID] == PN_PREFIX), KInvalidResourceId, KErrOverflow );

    ASSERT_RESET_ALWAYS( (iBuffer.Length() > ISI_HEADER_OFFSET_MESSAGEID), KInvalidResourceId, KErrOverflow );

    TUint8 temp(iBuffer[ ISI_HEADER_OFFSET_SUBTYPE ]);

    TUint32 subType = static_cast<TUint32>( temp << 16 );

    TUint32 type = static_cast<TUint32>( iBuffer[ ISI_HEADER_OFFSET_TYPE ] << 8 );