diff -r 000000000000 -r 1bce908db942 multimediacommsengine/mmceshared/inc/mceserial.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/multimediacommsengine/mmceshared/inc/mceserial.h Tue Feb 02 01:04:58 2010 +0200 @@ -0,0 +1,1058 @@ +/* +* 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 +#include +#include +#include + +#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& aArray, RWriteStream& aWriteStream ); + + static void DecodeL( RArray& 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 + **/ + CMceMsgSIPRequest(); + + + /** + * 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 + **/ + CMceMsgSIPRequest( HBufC8& aMethod, + CDesC8Array& aSIPHeaders, + HBufC8& aContentType ); + + /** + * Destructor + **/ + ~CMceMsgSIPRequest(); + + + /** + * 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 ); + + + +private: + + /** + * Destroys all (encoded) data + **/ + void Close(); + + /** + * Destroys all (encoded) data + **/ + void LocalClose(); + + + +public: + + // Returns the request Method, ownership is transfered. + HBufC8* RequestMethod(); + + +private://input/output + + HBufC8* iMethod; + }; + + + +/** + * Message for transferring SIP event + * between client and server + * + * @lib + */ +class CMceMsgSIPEvent : public CMceMsgSIPData + { +public: + + /** + * C++ constructor for decoding + **/ + CMceMsgSIPEvent(); + + /** + * C++ constructor for encoding + * @param aId data to be encoded + * @param aDialogId data to be encoded + * @param aEventType data to be encoded + * @param aRecipient data to be encoded + * @param aOriginator data to be encoded + * @param aEventHeader data to be encoded + * @param aReferTo data to be encoded + * @param aReferType data to be encoded + * @param aRefreshInterval data to be encoded + * @param aSIPHeaders data to be encoded + * @param aContentType data to be encoded + **/ + CMceMsgSIPEvent( TUint32 aId, + TUint32 aDialogId, + TMceItcEventType aEventType, + HBufC8* aRecipient, + HBufC8* aOriginator, + HBufC8* aEventHeader, + HBufC8* aReferTo, + CMceRefer::TType aReferType, + TUint32 aRefreshInterval, + CDesC8Array* aSIPHeaders, + HBufC8* aContentType ); + + /** + * C++ constructor for encoding + * @param aId data to be encoded + * @param aDialogId data to be encoded + * @param aEventType data to be encoded + * @param aReferType data to be encoded + * @param aRefreshInterval data to be encoded + * @param aSIPHeaders data to be encoded + * @param aContentType data to be encoded + **/ + CMceMsgSIPEvent( TUint32 aId, + TUint32 aDialogId, + TMceItcEventType aEventType, + CMceRefer::TType aReferType, + TUint32 aRefreshInterval, + CDesC8Array* aSIPHeaders, + HBufC8* aContentType ); + + ~CMceMsgSIPEvent(); + + /** + * 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 ); + +private: + + /** + * Destroys all (encoded) data + **/ + void Close(); + + /** + * Destroys all (encoded) data + **/ + void LocalClose(); + +public: + // Getters for members + + // Returns the ID. + TUint32 Id(); + + // Returns the dialog ID. + TUint32 DialogId(); + + // Returns the event type. + TUint32 EventType(); + + // Returns the recipient, ownership is transfered. + HBufC8* Recipient(); + + // Returns the originator, ownership is transfered. + HBufC8* Originator(); + + // Returns the event header, ownership is transfered. + HBufC8* EventHeader(); + + // Returns the refer-to header, ownership is transfered. + HBufC8* ReferTo(); + + // Returns the refer type. + TUint32 ReferType(); + + // Returns the refresh interval. + TUint32 RefreshInterval(); + + // Returns the SIP headers, ownership is transfered. + CDesC8Array* SIPHeaders(); + + // Returns the content type, ownership is transfered. + HBufC8* ContentType(); + +protected: + + /** + * Releases ownership of certain owned member data. + */ + void DoOwnershipRollback(); + +private://input/output + + TUint32 iId; + TUint32 iDialogId; + TUint32 iEventType; + HBufC8* iRecipient; + HBufC8* iOriginator; + HBufC8* iEventHeader; + HBufC8* iReferTo; + TUint32 iReferType; + TUint32 iRefreshInterval; + + //for testing + + MCE_UNIT_TEST_DEFS + }; + + + +/** + * Message for transferring objects between client and server + * The class of object must implement: + * - ExternalizeL( RWriteStream& aWriteStream ) + * - Factory(), which implements CreateLC( RReadStream& aReadStream ) + * + * @lib + */ +template +class CMceMsgObject : public CMceMsgBase + { +public: + + /** + * C++ constructor for decoding + **/ + inline CMceMsgObject(); + + /** + * C++ constructor for encoding + * @param aObject data to be encoded + * @param aItcType data to be encoded + **/ + inline CMceMsgObject( T& aObject, TMceItcDataType aItcType ); + + /** + * C++ destructor + **/ + inline ~CMceMsgObject(); + + /** + * Encodes message + **/ + inline void EncodeL(); + + /** + * Decodes message from stream + * @param aReadStream encoded string representing + * this message as stream + * @param aReadStream the stream + **/ + inline void DoDecodeL( RReadStream& aReadStream ); + + /** + * Decodes message from stream + * @param aSerCtx containing stream as encoded string representing + * this message as stream + **/ + inline void DoDecodeL( MMceComSerializationContext& aSerCtx ); + + /** + * Transfers ownership + * @return object + **/ + inline T* Object(); + + /** + * Destroys all (encoded) data + **/ + inline void Close(); + + /** + * Destroys all (encoded) data + **/ + inline void LocalClose(); + +public://input/output + + T* iObject; + + }; + + +/** + * Message for transferring arrays of messages + * between client and server + * + * @lib + */ +template +class CMceMsgArray : public CMceMsgBase + { +public: + + /** + * C++ constructor for encoding/decoding + * aFactory factory, which can encode messages + * based on message type + **/ + inline CMceMsgArray( T& aFactory ); + + inline ~CMceMsgArray(); + +public: + + /** + * Encodes message + **/ + inline void EncodeL(); + + /** + * Decodes message from stream + * @param aReadStream encoded string representing + * this message as stream + * @param aReadStream the stream + **/ + inline void DoDecodeL( RReadStream& aReadStream ); + + /** + * Destroys all (encoded) data + **/ + inline void Close(); + + /** + * Destroys all (encoded) data + **/ + inline void LocalClose(); + +public://input/output + + RPointerArray iArray; + T& iFactory; + + }; + + + +/** + * One-way stream serializer for Server and Client side stream + * + * @lib + */ +template +class TMceMediaStreamSerializer + { + +public: + + /** + * Constructor for internalization for server side + * @param aStream the stream + */ + inline TMceMediaStreamSerializer( T& aStream ); + + /** + * Constructor for internalization for client side + * @param aStream the stream + * @param aFlatData to which flat data is fetched + */ + inline TMceMediaStreamSerializer( T& aStream, CMceComMediaStream* aFlatData ); + + /** + * Internalizes + * @param aSerCtx context for serialization + */ + inline void InternalizeL( MMceComSerializationContext& aSerCtx ); + + /** + * Externalizes + * @param aSerCtx context for serialization + */ + inline void ExternalizeL( MMceComSerializationContext& aSerCtx ); + + +private: + + /** + * Server / client side stream + */ + T& iStream; + + /** + * Flat data container + */ + CMceComMediaStream* iFlatData; + + }; + + + +/** + * Session serializer for Server and Client side session + * + * @lib + */ +template +class TMceSessionSerializer + { + +public: + + /** + * Constructor for internalization for server side + * @param aSession the session + */ + inline TMceSessionSerializer( T& aSession ); + + /** + * Constructor for internalization for client side + * @param aSession the session + * @param aFlatData to which flat data is fetched + */ + inline TMceSessionSerializer( T& aSession, CMceComSession* aFlatData ); + + /** + * Internalizes + * @param aSerCtx context for serialization + */ + inline void InternalizeL( MMceComSerializationContext& aSerCtx ); + + /** + * Externalizes + * @param aSerCtx context for serialization + */ + inline void ExternalizeL( MMceComSerializationContext& aSerCtx ); + + +private: + + /** + * Server / client side session + */ + T& iSession; + + /** + * Flat data container + */ + CMceComSession* iFlatData; + + }; + + +/** + * audio stream serializer for Server and Client side stream + * + * @lib + */ +template +class TMceAudioStreamSerializer + { + +public: + + /** + * Constructor for internalization for server side + * @param aStream the stream + */ + inline TMceAudioStreamSerializer( T& aStream ); + + /** + * Internalizes + * @param aSerCtx context for serialization + */ + inline void InternalizeL( MMceComSerializationContext& aSerCtx ); + + /** + * Externalizes + * @param aSerCtx context for serialization + */ + inline void ExternalizeL( MMceComSerializationContext& aSerCtx ); + + +private: + + + /** + * Server / client side stream + */ + T& iAudioStream; + + }; + + +/** + * Video stream serializer for Server and Client side stream + * + * @lib + */ +template +class TMceVideoStreamSerializer + { + +public: + + /** + * Constructor for internalization for server side + * @param aStream the stream + */ + inline TMceVideoStreamSerializer( T& aStream ); + + /** + * Internalizes + * @param aSerCtx context for serialization + */ + inline void InternalizeL( MMceComSerializationContext& aSerCtx ); + + /** + * Externalizes + * @param aSerCtx context for serialization + */ + inline void ExternalizeL( MMceComSerializationContext& aSerCtx ); + + +private: + + + /** + * Server / client side stream + */ + T& iVideoStream; + + }; + + + + +#include "mceserial.inl" + + +#endif \ No newline at end of file