/*

* Copyright (c) 2006 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:  Base class for API implementations.

*

*/

#include "presenceeventcodec.h"

//#include "ximprequestcompleteeventimp.h"

//#include "ximpcontextstateeventimp.h"

#include "presentitygrouplisteventimp.h"

#include "ownpresenceeventimp.h"

#include "presentitypresenceeventimp.h"

#include "presentitygroupcontenteventimp.h"

#include "presencewatcherlisteventimp.h"

#include "presencegrantrequestlisteventimp.h"

#include "presenceblocklisteventimp.h"

#include "ximpapieventbase.h"

#include <s32strm.h>

#include <s32mem.h>

//DATA TYPES

/**

 * Type definition for exact API event constructor signature.

 */

typedef CXIMPApiEventBase* (*TApiEventConstructor)( RReadStream& );

/**

 * Structure for mapping event interface IDs to

 * to corect API event constructors.

 */

struct SApiEventConstructorMap

    {

    //Interface id

    TInt32    iInterfaceId;

    //Function pointer to event interface implementation

    TApiEventConstructor iConstructorPtr;

    } ;

/**

 * Helper macro to initialise KApiEventConstructorTable members.

 *

 * Macro forces that each event implementation class to have static

 * NewFromStreamLC() memeber function to instantiate the object.

 *

 * See TApiEventConstructor type definition for exact constructor

 * signature.

 */

#define CONSTRUCTOR_ENTRY( TheImplementedIf, TheClass ) \

    { TheImplementedIf::KInterfaceId, TheClass::NewFromStreamLC } \

/**

 * Constructor function mapping for event interface implementations.

 *

 * When new event types are implemented, add them here.

 */

const SApiEventConstructorMap KApiEventConstructorTable[] =

    {

//    CONSTRUCTOR_ENTRY( MXIMPRequestCompleteEvent, CXIMPRequestCompleteEventImp ),

//    CONSTRUCTOR_ENTRY( MXIMPContextStateEvent, CXIMPContextStateEventImp ),

    CONSTRUCTOR_ENTRY( MPresentityGroupListEvent, CPresentityGroupListEventImp ),

    CONSTRUCTOR_ENTRY( MOwnPresenceEvent, COwnPresenceEventImp ),

    CONSTRUCTOR_ENTRY( MPresentityPresenceEvent, CPresentityPresenceEventImp ),

    CONSTRUCTOR_ENTRY( MPresentityGroupContentEvent, CPresentityGroupContentEventImp ),

    CONSTRUCTOR_ENTRY( MPresenceWatcherListEvent, CPresenceWatcherListEventImp ),

    CONSTRUCTOR_ENTRY( MPresenceGrantRequestListEvent, CPresenceGrantRequestListEventImp ),

    CONSTRUCTOR_ENTRY( MPresenceBlockListEvent, CPresenceBlockListEventImp )

    };

/**

 * Count of constructor mappings.

 */

const TInt KApiEventConstructorCount = sizeof( KApiEventConstructorTable )

                                        / sizeof( SApiEventConstructorMap );

// ============================ HELPER FUNCTIONS =============================

/**

 * Helper function to locate constructor function for

 * event interface ID.

 *

 * @param aEventInterfaceId The event interface ID.

 * @return Event object constructor function.

 */

TApiEventConstructor ConstructorForInterface( TInt32 aEventInterfaceId )

    {

    //Locate correct constructor

    for( TInt ix = 0; ix < KApiEventConstructorCount; ix++ )

        {

        const SApiEventConstructorMap map = KApiEventConstructorTable[ ix ];

        if( map.iInterfaceId == aEventInterfaceId )

            {

            return map.iConstructorPtr;

            }

        }

    //If assertion below fails, check that event implementation

    //class implementing requested event interface (aEventInterfaceId)

    //is registered to KApiEventConstructorTable

//    __ASSERT_DEBUG( EFalse,

//                    User::Panic( _L("PresenceEventCodec"), KErrUnknown ) );

    return NULL;

    }

/**

 * Helper function to instantiate new event object

 * of requested type and construct it from the stream.

 *

 * @param aEventInterfaceId

 * @return Event object constructor function.

 */

CXIMPApiEventBase* NewEventObjectFromStreamLC( TInt32 aEventInterfaceId,

                                               RReadStream& aStream )

    {

    TApiEventConstructor newFromStreamLC = NULL;

    //Locate correct constructor for interface ID

    newFromStreamLC = ConstructorForInterface( aEventInterfaceId );

	if( ! newFromStreamLC )

	    {

	    return 	NULL;

	    }

    //Instantiate the object

    CXIMPApiEventBase* eventObject = newFromStreamLC( aStream );

    return eventObject;

    }

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

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

// CPresenceEventCodec::NewL()

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

//

CPresenceEventCodec* CPresenceEventCodec::NewL()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CPresenceEventCodec::ConstructL()

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

//

void CPresenceEventCodec::ConstructL()

    {

    }

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

// CPresenceEventCodec::CPresenceEventCodec()

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

//

CPresenceEventCodec::CPresenceEventCodec()

    {

    }

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

// CPresenceEventCodec::~CPresenceEventCodec()

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

//

CPresenceEventCodec::~CPresenceEventCodec()

    {

    }

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

// CPresenceEventCodec::PackL()

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

//

HBufC8* CPresenceEventCodec::PackL( CXIMPApiEventBase& aEventObj,

                                        TInt32& aTypeOfEvent )

    {

    CBufFlat* buffer = CBufFlat::NewL( 10 ); // initial granularity to 10

    CleanupStack::PushL( buffer );

    RBufWriteStream ws;

    CleanupClosePushL( ws );

    ws.Open( *buffer ); // CSI: 65 #

    //Ask real event type through the event base interface

    TInt32 eventIfId = aEventObj.Base().GetInterfaceId();

    //And write both event type and data

    ws.WriteInt32L( eventIfId );

    aEventObj.ExternalizeL( ws );

    ws.CommitL();

    CleanupStack::PopAndDestroy();  //ws

    HBufC8* heapBuf = buffer->Ptr( 0 ).AllocL();

    CleanupStack::PopAndDestroy( buffer );

    aTypeOfEvent = eventIfId;

    return heapBuf;

    }

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

// CPresenceEventCodec::PackL()

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

//

void CPresenceEventCodec::PackL( CXIMPApiEventBase& aEventObj,

                                     TInt32& aTypeOfEvent,

                                     CBufFlat* aBuffer )

    {

    RBufWriteStream ws;

    CleanupClosePushL( ws );

    ws.Open( *aBuffer ); // CSI: 65 #

    //Ask real event type through the event base interface

    TInt32 eventIfId = aEventObj.Base().GetInterfaceId();

    //And write both event type and data

    ws.WriteInt32L( eventIfId );

    aEventObj.ExternalizeL( ws );

    ws.CommitL();

    CleanupStack::PopAndDestroy();  //ws

    aTypeOfEvent = eventIfId;

    }

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

// CPresenceEventCodec::UnPackL()

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

//

CXIMPApiEventBase* CPresenceEventCodec::UnPackL( const TDesC8& aEventData,

                                                     TInt32& aTypeOfEvent )

    {

    RDesReadStream rs;

    rs.Open( aEventData ); // CSI: 65 #

    CleanupClosePushL( rs );

    TInt32 eventIfId = rs.ReadInt32L();

    CXIMPApiEventBase* eventObject = NewEventObjectFromStreamLC( eventIfId, rs );

    if(eventObject)

    	{

    	CleanupStack::Pop(); //eventObject

    	}

    CleanupStack::PopAndDestroy(); // rs

    aTypeOfEvent = eventIfId;

    return eventObject;

    }

// End of file