/*

* Copyright (c) 2009-2010 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:

* MSRP Implementation

*

*/

// CLASS HEADER

#include "CMsrpMessage.h"

// EXTERNAL INCLUDES

#include <MsrpStrConsts.h>

// INTERNAL INCLUDES

#include "MsrpCommon.h"

#include "CMSRPFromPathHeader.h"

#include "CMSRPToPathHeader.h"

#include "CMSRPMessageIdHeader.h"

#include "CMSRPByteRangeHeader.h"

#include "CMSRPContentTypeHeader.h"

#include "CMSRPFailureReportHeader.h"

#include "CMSRPSuccessReportHeader.h"

#include "TMSRPHeaderUtil.h"

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

// CMSRPMessage::CMSRPMessage

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

//

EXPORT_C CMSRPMessage::CMSRPMessage()

	{

	}

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

// CMSRPMessage::~CMSRPMessage

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

//

EXPORT_C CMSRPMessage::~CMSRPMessage()

	{

	delete iContentBuffer;

	}

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

// CMSRPMessage::SetContentL

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

//

EXPORT_C void CMSRPMessage::SetContent( HBufC8* aContent )

	{

    if( iContentBuffer )

        {

        delete iContentBuffer;

        iContentBuffer = NULL;

        }

	iContentBuffer = aContent;

	}

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

// CMSRPMessage::Content

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

//

EXPORT_C const TDesC8& CMSRPMessage::Content( )

	{

    if( iContentBuffer )

        {

        return *iContentBuffer;

        }

	return KNullDesC8();

	}

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

// CMSRPMessage::IsContent

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

//

EXPORT_C TBool CMSRPMessage::IsContent( ) const

	{

	if ( iContentBuffer )

		{

		return ETrue;

		}

	return EFalse;

	}

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

// CMSRPMessage::SetFileName

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

//

EXPORT_C void CMSRPMessage::SetFileName( const TFileName& aFileName )

    {

    iFileName = aFileName;

    }

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

// CMSRPMessage::GetFileName

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

//

EXPORT_C TFileName& CMSRPMessage::GetFileName( )

    {

    return iFileName;

    }

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

// CMSRPMessage::SetFileSize

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

//

EXPORT_C void CMSRPMessage::SetFileSize( const TInt aFileSize )

    {

    iFileSize = aFileSize;

    }

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

// CMSRPMessage::GetFileSize

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

//

EXPORT_C TInt CMSRPMessage::GetFileSize( )

    {

    return iFileSize;

    }

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

// CMSRPMessage::InternalizeL

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

//

EXPORT_C CMSRPMessage* CMSRPMessage::InternalizeL( RReadStream& aReadStream )

	{

	CMSRPMessage* self = new (ELeave) CMSRPMessage();

	CleanupStack::PushL( self );

    self->DoInternalizeL( aReadStream );

	CleanupStack::Pop( self );

    return self;

	}

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

// CMSRPMessage::DoInternalizeL

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

//

void CMSRPMessage::DoInternalizeL( RReadStream& aReadStream )

    {

    TUint8 dataType( 0 );

    // read the identifier

    if ( aReadStream.ReadUint8L() != 100 )

        {

        User::Leave( KErrArgument );

        }

    do

        {

        dataType = aReadStream.ReadUint8L();

        switch( dataType )

            {

            case 1: // from path

                {

                iFromPath = CMSRPFromPathHeader::InternalizeValueL( aReadStream );

                break;

                }

            case 2: // to path

                {

                iToPath = CMSRPToPathHeader::InternalizeValueL( aReadStream );

                break;

                }

            case 3: // message id

                {

                iMessageId = CMSRPMessageIdHeader::InternalizeValueL( aReadStream );

                break;

                }

            case 4: // byte range

                {

                iByteRange = CMSRPByteRangeHeader::InternalizeValueL( aReadStream );

                break;

                }

            case 5: // content type

                {

                iContentType = CMSRPContentTypeHeader::InternalizeValueL( aReadStream );

                break;

                }

            case 6: // failure report

                {

                iFailureReport = CMSRPFailureReportHeader::InternalizeValueL( aReadStream );

                break;

                }

            case 7: // success report

                {

                iSuccessReport = CMSRPSuccessReportHeader::InternalizeValueL( aReadStream );

                break;

                }

            case 10: // content buffer

                {

                TUint32 contentLength = aReadStream.ReadUint32L();

                iContentBuffer = HBufC8::NewL( contentLength );

                TPtr8 bufferPtr = iContentBuffer->Des();

                aReadStream.ReadL( bufferPtr, contentLength );

                break;

                }

            case 11: //filename

                {

                 TUint32 nameLength = aReadStream.ReadUint32L();

                 aReadStream.ReadL( iFileName, nameLength );

                 break;

                }

            case 12: //filesize

                 {

                  TUint32 val = aReadStream.ReadUint32L();

                  if( val > 0 )

                    {

                    HBufC8* tempString = HBufC8::NewLC( val );

                    TPtr8 tempValue( tempString->Des() );

                    aReadStream.ReadL( tempValue, val );

                    iFileSize = TMSRPHeaderUtil::ConvertToNumber( tempString->Des() );

                    CleanupStack::PopAndDestroy( tempString );

                    }

                   break;              

                  }         

            case 13: //granularity

                  {

                 TUint32 val = aReadStream.ReadUint32L();

                 if( val > 0 )

                    {

                     HBufC8* tempString = HBufC8::NewLC( val );

                     TPtr8 tempValue( tempString->Des() );

                     aReadStream.ReadL( tempValue, val );

                     iNotifyProgress = TMSRPHeaderUtil::ConvertToNumber( tempString->Des() );

                     CleanupStack::PopAndDestroy( tempString );

                     }

                 break;              

                  }                 

            default:

                {

                // nothing to do

                break;

                }

            }

        } while( dataType );

    }

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

// CMSRPMessage::ExternalizeL

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

//

EXPORT_C void CMSRPMessage::ExternalizeL( RWriteStream& aWriteStream )

        {

        // first add the MSRP Message identifier

        aWriteStream.WriteUint8L( 100 ); // MSRP Message identifier

        if( iFromPath )

            {

            aWriteStream.WriteUint8L(1); // more headers in the stream flag

            iFromPath->ExternalizeValueL( aWriteStream );

            }

        if( iToPath )

            {

            aWriteStream.WriteUint8L(2); // more headers in the stream flag

            iToPath->ExternalizeValueL( aWriteStream );

            }

        if ( iMessageId )

            {

            aWriteStream.WriteUint8L(3); // more headers in the stream flag

            iMessageId->ExternalizeValueL( aWriteStream );

            }

        if( iByteRange )

            {

            aWriteStream.WriteUint8L(4); // more headers in the stream flag

            iByteRange->ExternalizeValueL( aWriteStream );

            }

        if( iContentType )

            {

            aWriteStream.WriteUint8L(5); // more headers in the stream flag

            iContentType->ExternalizeValueL( aWriteStream );

            }

        if( iFailureReport )

            {

            aWriteStream.WriteUint8L(6); // more headers in the stream flag

            iFailureReport->ExternalizeValueL( aWriteStream );

            }

        if( iSuccessReport )

            {

            aWriteStream.WriteUint8L(7); // more headers in the stream flag

            iSuccessReport->ExternalizeValueL( aWriteStream );

            }

        if ( IsContent() )

            {

            aWriteStream.WriteUint8L( 10 ); 

            aWriteStream.WriteInt32L( iContentBuffer->Length()  );

            aWriteStream.WriteL( *iContentBuffer, iContentBuffer->Length() );

            }

        if ( IsFile() )

            {

            aWriteStream.WriteUint8L( 11 ); // 2 = file ID

            aWriteStream.WriteInt32L( iFileName.Length() );

            aWriteStream.WriteL( iFileName );

            }

        if( iFileSize > 0 )

            {

            aWriteStream.WriteUint8L( 12 );

            TBuf8< 50 > val;

            val.AppendNum( iFileSize );

            aWriteStream.WriteInt32L( val.Length() );

            aWriteStream.WriteL( val );

             }

        if( iNotifyProgress > 0 )

            {

            aWriteStream.WriteUint8L( 13 );

            TBuf8< 50 > val;

            val.AppendNum( iNotifyProgress );

            aWriteStream.WriteInt32L( val.Length() );

            aWriteStream.WriteL( val );

             }

        aWriteStream.WriteUint8L(0); // no more headers in the stream flag

        }

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

// CMSRPMessage::IsMessage

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

//

EXPORT_C TBool CMSRPMessage::IsMessage( const TDesC8& aBuffer )

	{

	if ( aBuffer.Length() )

		{

		if ( aBuffer[ 0 ] == 100 )

			{

			return ETrue;

			}

		}

	return EFalse;

	}

EXPORT_C TBool CMSRPMessage::IsFile()

    {

   if ( iFileName.Length() )

        {

        return ETrue;

        }

    return EFalse;

}

EXPORT_C void CMSRPMessage::SetNotifyProgress(TBool aNotify)

      {

      iNotifyProgress = aNotify;

      }

EXPORT_C TBool CMSRPMessage::GetNotifyProgress()

      {

      return iNotifyProgress;

      } 

// End of File