/*

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

*

*/

#include "mcecommsrpsink.h"

#include "mcecommediastream.h"

#include "mcecomsession.h"

#include "mcemsrpsink.h"

#include "mceserial.h"

#ifdef MCE_COMMON_SERVER_SIDE

#include <mmccInterface.h>

#include "mcesdpsession.h"

#include "mcemediamanager.h"

#endif//MCE_COMMON_SERVER_SIDE

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

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

// CMceComAvSink::NewL

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

//

CMceComMsrpSink* CMceComMsrpSink::NewL()

    {

    CMceComMsrpSink* self = NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// CMceComMsrpSink::NewLC

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

//

CMceComMsrpSink* CMceComMsrpSink::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CMceComMsrpSink::~CMceComMsrpSink

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

//

CMceComMsrpSink::~CMceComMsrpSink()

    { 

    iPath.ResetAndDestroy();

    delete iFileName;

    delete iSessInfo;

    delete iFileType;

    }

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

// CMceComMsrpSink::CMceComMsrpSink

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

//

CMceComMsrpSink::CMceComMsrpSink()

  :CMceComMediaSink( KMceMSRPSink),

  iPath(KMceArrayGranularity),

  iSessInfo(NULL),

  iAcceptTypes(KMceArrayGranularity),

  iAcceptWrappedTypes (KMceAcceptWrappedTypes),

  iWrappedTypes(EFalse),

  iFileShare(EFalse),

  iFileName(NULL)

    {

    }

void CMceComMsrpSink::ConstructL(CMceComMsrpSink& aSource )

    { 

    iPath.ResetAndDestroy();

    for(int i=0;i<aSource.iPath.Count();i++)

        {       

        //TUriParser8 parser;

        TUriParser8* parser = new (ELeave) TUriParser8;

        parser->Parse(aSource.iPath[i]->UriDes());

        CleanupStack::PushL(parser);

        iPath.AppendL(parser);        

        CleanupStack::Pop(parser);

        }

    if (iSessInfo!=NULL)

        {

        delete iSessInfo;

        iSessInfo = NULL;

        }

    if (aSource.iSessInfo!=NULL)

        {

        iSessInfo = aSource.iSessInfo->Des().AllocL();

        }

    for(int i=0; i<aSource.iAcceptTypes.MdcaCount();i++)

        {

        iAcceptTypes.AppendL(aSource.iAcceptTypes.MdcaPoint(i) ); 

        }

    iAcceptWrappedTypes = aSource.iAcceptWrappedTypes;

    iWrappedTypes = aSource.iWrappedTypes;

    iFileShare = aSource.iFileShare;

    if (iFileName!=NULL)

        {

        delete iFileName;

        iFileName = NULL;

        }

    if (aSource.iFileName!=NULL)

         {

         iFileName = aSource.iFileName->Des().AllocL();

         }

    iFileSize = aSource.iFileSize;

    iFileTransferid = aSource.iFileTransferid;

    iDispositionValue = aSource.iDispositionValue;

    iSecureConnection = aSource.iSecureConnection;

    if (iFileType!=NULL)

        {

        delete iFileType;

        iFileType = NULL;

        }

    if (aSource.iFileType!=NULL)

        {

        iFileType = aSource.iFileType->Des().AllocL();

        }

    iFTProgressNotification = aSource.iFTProgressNotification;

    }

void CMceComMsrpSink::ConstructL()

    {

    iFTProgressNotification = ETrue;

    }

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

// CMceComMsrpSink::CloneL

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

//

CMceComMediaSink* CMceComMsrpSink::CloneL()

    {

    CMceComMsrpSink* copy = CMceComMsrpSink::NewLC();

    copy->ConstructL(*this);

    CleanupStack::Pop(copy);

    return copy;

    }

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

// CMceComMsrpSink::InternalizeFlatL

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

//

void CMceComMsrpSink::InternalizeFlatL( RReadStream& aReadStream )

    {

    CMceComMediaSink::InternalizeFlatL( aReadStream );

    MceSerial::DecodeL(this->iPath, aReadStream);

    MceSerial::DecodeL(this->iSessInfo, aReadStream);

    CDesC8Array* array = NULL;

    MceSerial::DecodeL(array, aReadStream);

    if (array)

        {

        this->iAcceptTypes.Reset();

        for (TInt i=0;i<array->MdcaCount();i++)

            {

            this->iAcceptTypes.AppendL(array->MdcaPoint(i)); 

            }

        delete array; // free up the memory

        }    

    MceSerial::DecodeL(this->iAcceptWrappedTypes, aReadStream);

    this->iWrappedTypes = aReadStream.ReadInt8L();

    this->iFileShare = aReadStream.ReadInt8L();

    MceSerial::DecodeL(this->iFileName, aReadStream);

    this->iFileSize = aReadStream.ReadUint32L();

    MceSerial::DecodeL(this->iFileType, aReadStream);

    MceSerial::DecodeL(this->iFileTransferid, aReadStream);

    MceSerial::DecodeL(this->iDispositionValue, aReadStream);

    this->iSecureConnection = aReadStream.ReadInt8L(); 

    MceSerial::DecodeL(this->iFilePath, aReadStream);

    this->iFTProgressNotification = aReadStream.ReadInt8L();

    }

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

// CMceComMsrpSink::ExternalizeFlatL

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

//

void CMceComMsrpSink::ExternalizeFlatL( RWriteStream& aWriteStream )

    {

    CMceComMediaSink::ExternalizeFlatL( aWriteStream );

    MceSerial::EncodeL(this->iPath, aWriteStream);

    MceSerial::EncodeL(this->iSessInfo, aWriteStream);

    MceSerial::EncodeL(&(this->iAcceptTypes), aWriteStream);

    MceSerial::EncodeL(this->iAcceptWrappedTypes, aWriteStream);

    aWriteStream.WriteInt8L(this->iWrappedTypes);

    aWriteStream.WriteInt8L(this->iFileShare);

    MceSerial::EncodeL(this->iFileName, aWriteStream);

    aWriteStream.WriteUint32L(this->iFileSize);

    MceSerial::EncodeL(this->iFileType, aWriteStream);

    MceSerial::EncodeL(this->iFileTransferid, aWriteStream);

    MceSerial::EncodeL(this->iDispositionValue, aWriteStream);

    aWriteStream.WriteInt8L(this->iSecureConnection);

    MceSerial::EncodeL(this->iFilePath, aWriteStream);

    aWriteStream.WriteInt8L(this->iFTProgressNotification);

    }

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

// CMceComMsrpSink::UpdateL

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

//

void CMceComMsrpSink::UpdateL( CMceComMediaSink& aUpdate )

    {

    CMceComMediaSink::UpdateL( aUpdate );

    CMceComMsrpSink& update = static_cast<CMceComMsrpSink&>( aUpdate );

    //Set MSRP path member

    if (update.iPath.Count() > 0)

        {

        iPath.ResetAndDestroy();

        for(int i=0;i<update.iPath.Count();i++)

            {        

            TUriParser8* parser = new (ELeave) TUriParser8;

            CleanupStack::PushL(parser);

            User::LeaveIfError(parser->Parse(update.iPath[i]->UriDes()) );

            iPath.AppendL(parser);        

            CleanupStack::Pop(parser);

            }

        }

    //Set Accept-types member

    if (update.iAcceptTypes.MdcaCount() > 0)

        {

        iAcceptTypes.Reset();

        for(int i=0; i<update.iAcceptTypes.MdcaCount();i++)

            {       

            iAcceptTypes.AppendL(update.iAcceptTypes.MdcaPoint(i));        

            }    

        }

    //Set secureconneciton member

    if (iSecureConnection != update.iSecureConnection)

        {

        iSecureConnection = update.iSecureConnection;

        }

    if (update.iAcceptWrappedTypes.Size())

        {

        iAcceptWrappedTypes = update.iAcceptWrappedTypes;

        iWrappedTypes = update.iWrappedTypes;

        }

    // look for the updaitons for file share attributes

    this->UpdateFileShareAttrL(update);

    if (update.iSessInfo != NULL )

        {

        delete iSessInfo ;

        iSessInfo = NULL;

        iSessInfo =  update.iSessInfo->Des().AllocL() ;

        }

    iFTProgressNotification = update.iFTProgressNotification;

    }

void CMceComMsrpSink::UpdateFileShareAttrL(CMceComMsrpSink& aUpdate )

	{

	    //Set FileSharing Attributes

	if(aUpdate.iFileShare || aUpdate.iFileTransferid.Length() || aUpdate.iDispositionValue.Size() )

		{

		iFileShare = aUpdate.iFileShare;

        if (iFileName!=NULL )

            {

            delete iFileName;

            iFileName = NULL;

            }

        iFileName = aUpdate.iFileName->Des().AllocL();

		iFileSize = aUpdate.iFileSize;

		if (iFileType!=NULL )

		    {

            delete iFileType;

            iFileType = NULL;

		    }

		iFileType = aUpdate.iFileType->Des().AllocL();

		//iFileType = aUpdate.iFileType;

		iFileTransferid = aUpdate.iFileTransferid;

		iDispositionValue = aUpdate.iDispositionValue;

		}

	}

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

// CMceComMsrpSink::UseRTCP

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

//

TBool CMceComMsrpSink::UseRTCP()

    {

    return EFalse;

    }

#ifdef MCE_COMMON_SERVER_SIDE

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

// CMceComMsrpSink::MccType

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

//

const TUid CMceComMsrpSink::MccType()

    {

    return KUidMccMsrpSink;

    }

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

// CMceComMsrpSink::PrepareL

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

//

void CMceComMsrpSink::PrepareL()

    {

    //NOP  // Not required as the data path for message stream will be handled by applications

    }

#endif//MCE_COMMON_SERVER_SIDE