/*

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

*

*/

#ifndef MCESERIAL_H

#define MCESERIAL_H

#include <e32std.h>  	

#include <s32strm.h>

#include <s32mem.h>

#include <e32des8.h>

#include "mcerefer.h"

#include "mcecomsession.h"

#include "mcecomaudiostream.h"

#include "mcecomvideostream.h"

#include "mcecomstreambundle.h"

#include "mceclientserver.h"

#include "mcefactory.h"

#include "mcecomfactory.h"

#include "mcecomserializationcontext.h"

class CMceManager;

class CSIPProfile;

#define MCE_DELETE( val ) delete val;val=NULL

#define MCE_HAS_DATA( buf ) ( buf && buf->Length() > 0 )

#define MCE_MOVE_BUFPTR( from, to ) HBufC8* to = from;from=NULL

#define MCE_MOVE_ARRPTR( from, to ) CDesC8Array* to = from;from=NULL

#define MCE_IS_ERROR( error ) ( error < KErrNone )

#define MCE_NEED_TO_SEND( session, receivedSdp )\

    ( session.NeedToSend( receivedSdp ) ||\

      session.FCActions().NeedToSendOffer() )

#define MCE_NEED_TO_RECEIVE( session ) session.NeedToReceive()

#define MCE_FORCED_TO_RECEIVE( session ) session.ForceSDPSendingStatus()

_LIT8( KMceEmpty, "" );

enum TMceContentType

    {

    EMceContentTypeUserDefined,

    EMceContentTypeSDP,

    EMceContentTypeMultiPart

    };

/**

 * static class providing decoding and  encoding

 * functionality of basic data types.

 *

 * @lib 

 */

class MceSerial

    {

public:

    /**

     * Decodes descriptor from stream

     * @param aString placeholder for data to be read from stream

     * @param aReadStream stream from which data is decoded

     **/

    static void DecodeL( TDes8& aString, RReadStream& aReadStream );

    /**

    * Encodes descriptor to stream

    * @param aString string to be encoded to stream

    * @param aWriteStream stream to which string is encoded

    **/

    static void EncodeL( const TDesC8& aString, RWriteStream& aWriteStream );

    /**

     * Encodes string buffer to stream. If buffer is NULL empty string is encoded

     * @param aString string buffer to be encoded to stream

     * @param aWriteStream stream to which string is encoded

     **/

    static void EncodeL( HBufC8* aString, RWriteStream& aWriteStream );

    /**

     * Decodes string buffer from stream

     * @param aBuffer placeholder for data to be read from stream

     * @param aReadStream stream from which data is decoded

     **/

    static void DecodeL( HBufC8*& aBuffer, RReadStream& aReadStream );

    /**

     * Decodes descriptor array from stream

     * @param aArray placeholder for data to be read from stream

     * @param aReadStream stream from which data is decoded

     **/

    static void DecodeL( CDesC8Array*& aArray, RReadStream& aReadStream );

    /**

     * Encodes descriptor array  to stream. If arrays is NULL empty arrays is encoded

     * @param aArray  descriptor array to be encoded to stream

     * @param aWriteStream stream to which string is encoded

     **/

    static void EncodeL( CDesC8Array* aArray, RWriteStream& aWriteStream );

    /**

     * Decodes media id from stream

     * @param aId placeholder for data to be read from stream

     * @param aReadStream stream from which data is decoded

     **/

    static void DecodeL( TMceMediaId& aId, RReadStream& aReadStream );

    /**

     * Encodes media id to stream. 

     * @param aId media id  to be encoded to stream

     * @param aWriteStream stream to which media id is encoded

     **/

    static void EncodeL( TMceMediaId aId, RWriteStream& aWriteStream );

	static void EncodeL( RArray<TMceCryptoContext>& aArray, RWriteStream& aWriteStream  );

    static void DecodeL( RArray<TMceCryptoContext>& aArray, RReadStream& aReadStream );

    };

/**

 * Base class of messages passed between client and server

 *

 * @lib 

 */

class CMceMsgBase : public CBase

    {

public:

    /**

    * C++ constructor

    * @param aType  the type of message

    **/

    CMceMsgBase( TMceItcDataType aType );

    /**

    * C++ destructor

    **/

    ~CMceMsgBase();

    /**

     * Encodes message

     **/

    virtual void EncodeL() = 0;

    /**

     * Decodes message from descriptor

     * @param aContext encoded string representing this message

     **/

    void DecodeL( const TDesC8& aContext );

    /**

    * Decodes message from stream

    * @param aReadStream encoded string representing 

    * this message as stream

    * @param aReadStream the stream

    **/

    virtual void DoDecodeL( RReadStream& aReadStream ) = 0;

    /**

    * Decodes message from stream

    * @param aSerCtx containing stream as encoded string representing 

    * this message as stream

    **/

    virtual void DoDecodeL( MMceComSerializationContext& aSerCtx );

    /**

    * Returns type of message

    * @returnt ype of message

    **/

    TMceItcDataType Type();

    /**

    * Returns buffer to which messge has been encoded

    * @return buffer to which messge has been encoded

    **/

    CBufFlat& EncodeBuffer();

    /**

    * Clones encode buffer

    * @return cloned encode buffer

    **/

    HBufC8* EncodeBufferCloneL();

    /**

    * Pushes all (encoded) data to cleanup stack

    **/

	virtual void PushL();

    /**

    * Pops all (encoded) data from cleanup stack

    **/

	virtual void Pop();

    /**

    * Destroys all (encoded) data

    **/

    virtual void Close() = 0;

    /**

    * Handles ownership rollback of leave situations.

    **/

    void OwnershipRollbackPushLC();

protected:

    /**

	* TCleanupItem funtion.

	*/

	static void OwnershipRollback( TAny* aData );

    /**

    * Releases ownership of certain owned member data.

    */

    virtual void DoOwnershipRollback();

protected://output

    CBufFlat* iEncodeBuf;

    TMceItcDataType iType;

    TBool iPushed;

    };

/**

 * Message for transferring descriptor array

 * between client and server

 *

 * @lib 

 */

class CMceMsgTextArray : public CMceMsgBase

    {

public:

    /**

    * C++ constructor for decoding

    **/

    CMceMsgTextArray();

    /**

    * C++ constructor for encoding

    * @param aArray data to be encoded

    **/

    CMceMsgTextArray( CDesC8Array& aArray );

    /**

    * Destructor

    **/

    ~CMceMsgTextArray();

    /**

     * Encodes message

     **/

    void EncodeL();

    /**

    * Decodes message from stream

    * @param aReadStream encoded string representing 

    * this message as stream

    * @param aReadStream the stream

    **/

    void DoDecodeL( RReadStream& aReadStream );

    /**

    * Destroys all (encoded) data

    **/

	void Close();

    /**

    * Destroys all (encoded) data

    **/

	void LocalClose();

    /**

    * Transfers ownership

    * @return array 

    **/

    CDesC8Array* Array();

public://input/output

    CDesC8Array* iArray;

    };

/**

 * Message for transferring SIP data

 * between client and server

 *

 * @lib 

 */

class CMceMsgSIPData : public CMceMsgBase

    {

public:

    /**

    * C++ constructor for decoding

    **/

    CMceMsgSIPData();

    /**

    * C++ constructor for encoding

    * @param aTrxType data to be encoded

    * @param aSIPHeaders data to be encoded

    * @param aContentType data to be encoded

    **/

    CMceMsgSIPData( TUint32 aTrxType,

                    CDesC8Array& aSIPHeaders,

                    HBufC8& aContentType );

    /**

    * Destructor

    **/

    ~CMceMsgSIPData();

protected:

    /**

    * C++ constructor for encoding

    * @param aType type of message

    **/

    CMceMsgSIPData( TMceItcDataType aType );

    /**

    * C++ constructor for encoding

    * @param aType type of message

    * @param aTrxType data to be encoded

    * @param aSIPHeaders data to be encoded

    * @param aContentType data to be encoded

    **/

    CMceMsgSIPData( TMceItcDataType aType,

                    TUint32 aTrxType,

                    CDesC8Array& aSIPHeaders,

                    HBufC8& aContentType );

    /**

    * Encodes message to stream

    * @param aWriteStream the stream

    **/

    void EncodeStreamL( RBufWriteStream& aWriteStream );

public:

    /**

     * Encodes message

     **/

    void EncodeL();

    /**

    * Decodes message from stream

    * @param aReadStream encoded string representing 

    * this message as stream

    * @param aReadStream the stream

    **/

    void DoDecodeL( RReadStream& aReadStream );

    /**

    * Destroys all (encoded) data

    **/

	void Close();

    /**

    * Destroys all (encoded) data

    **/

	void LocalClose();

    /**

    * Transfers ownership

    * @return SIP headers 

    **/

    CDesC8Array* Headers();

    /**

    * Transfers ownership

    * @return content type 

    **/

    HBufC8* ContentType();

protected:

    /**

    * Releases ownership of certain owned member data.

    */

    void DoOwnershipRollback();

public://input/output

    //method code from SipStrings

    TUint32 iTrxType;

    //sip headers

    CDesC8Array* iSIPHeaders;

    //content type

    HBufC8* iContentType;

public://internal 

    TMceContentType iContentTypeId;

    };

/**

 * Message for transferring SIP reply

 * between client and server

 *

 * @lib 

 */

class CMceMsgSIPReply : public CMceMsgSIPData

    {

public:

    /**

    * C++ constructor for decoding

    **/

    CMceMsgSIPReply();

    /**

    * C++ constructor for encoding

    * @param aTrxType data to be encoded

    * @param aReason data to be encoded

    * @param aCode data to be encoded

    * @param aSIPHeaders data to be encoded

    * @param aContentType data to be encoded

    **/

    CMceMsgSIPReply( TUint32 aTrxType,

                     HBufC8& aReason, TUint32 aCode,

                     CDesC8Array& aSIPHeaders,

                     HBufC8& aContentType );

    /**

    * C++ constructor for encoding

    * @param aReason data to be encoded

    * @param aCode data to be encoded

    * @param aSIPHeaders data to be encoded

    * @param aContentType data to be encoded

    **/

    CMceMsgSIPReply( HBufC8& aReason, TUint32 aCode,

                     CDesC8Array& aSIPHeaders,

                     HBufC8& aContentType );

    /**

    * Destructor

    **/

    ~CMceMsgSIPReply();

    /**

    * Encodes message

    **/

    void EncodeL();

    /**

    * Decodes message from stream

    * @param aReadStream encoded string representing 

    * this message as stream

    * @param aReadStream the stream

    **/

    void DoDecodeL( RReadStream& aReadStream );

    /**

    * Destroys all (encoded) data

    **/

	void Close();

    /**

    * Destroys all (encoded) data

    **/

	void LocalClose();

    /**

    * Transfers ownership

    * @return reason 

    **/

    HBufC8* Reason();

public://input/output

    HBufC8* iReason;

    TUint32 iCode;

public://internal

    TInt iReasonAsPoolIndex;    

    };

/** 

 * Message for transferring SIP request

 * between client and server

 *

 * @lib 

 */

class CMceMsgSIPRequest : public CMceMsgSIPData

    {

public:

    /**

    * C++ constructor for decoding

    **/