/*

* 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:  Context session.

 *

*/

#include "ximpcontextsession.h"

#include "ximpsrvmessage.h"

#include "ximpserverdefs.h"

#include "ximpcontexteventqueue.h"

#include "ximpcontexteventfilter.h"

#include "ximphostmanager.h"

#include "ximpglobals.h"

#include "ximppsccontextimp.h"

#include "ximpfeatureinfoimp.h"

#include "ximpobjecthelpers.h"

#include "ximppanics.h"

#include "ximptrace.h"

#include "ximpoperationdefs.h"

#include "ximpoperationbase.h"

#include "ximphoststates.h"

#include <ximpbase.h>

#include <e32base.h>

using namespace NXIMPSrv;

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

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

// CXIMPContextSession::NewL()

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

//

CXIMPContextSession* CXIMPContextSession::NewL( TUint32 aSessionId )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL( aSessionId );

    CleanupStack::Pop( self );

    return self;

    }

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

// CXIMPContextSession::~CXIMPContextSession()

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

//

CXIMPContextSession::~CXIMPContextSession()

    {

    TRACE_1( _L("CXIMPContextSession[%d]::~CXIMPContextSession()"), this );

    delete iPreparedData;

    if( iEventListenScout )

        {

        iEventListenScout->Complete( KErrCancel );

        delete iEventListenScout;

        }

    iClientData->EventQueue().StopConsuming();

    // Unbind when client has died, and unbind not send.

    CXIMPOperationBase* operation = iClientData->GetCachedUnbind();

    if( operation )

        {

        TRAP_IGNORE(

            {

            CleanupStack::PushL( operation );

            iClientData->AppendToOpQueueL( operation );

            CleanupStack::Pop( operation );

            } );

        }

    iClientData->Close();

    }

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

// CXIMPContextSession::CXIMPContextSession()

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

//

CXIMPContextSession::CXIMPContextSession()

    {

    TRACE_1( _L("CXIMPContextSession[%d]::CXIMPContextSession()"), this );

    }

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

// CXIMPContextSession::ConstructL()

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

//

void CXIMPContextSession::ConstructL( TUint32 aSessionId )

    {

    iClientData = CXIMPPscContext::NewL( aSessionId );

    }

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

// CXIMPContextSession::TryHandleMessageL()

// From MXIMPSrvSession

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

//

void CXIMPContextSession::TryHandleMessageL( MXIMPSrvMessage& aMessage )

    {

    switch( aMessage.Function() )

        {

        //Asynchronous context operations related

        case NRequest::ECtxSsQueueOperation:

            {

            DoQueueOperationL( aMessage );

            break;

            }

        //Asynchronous context operations related

        case NRequest::ECtxSsQueueBindOperation:

            {

            DoQueueOperationL( aMessage );

            break;

            }

        //Event handling related

        case NRequest::ECtxSsInstallEventFilter:

            {

            DoInstallEventFilterL( aMessage );

            break;

            }

        case NRequest::ECtxSsSetEventListenScout:

            {

            DoSetEventListenScoutL( aMessage );

            break;

            }

        case NRequest::ECtxSsCancelEventListenScout:

            {

            DoCancelEventListenScout( aMessage );

            break;

            }

        case NRequest::ECtxSsFetchTopEventDataSize:

            {

            DoFetchTopEventDataSizeL( aMessage );

            break;

            }

        case NRequest::ECtxSsFetchTopEventData:

            {

            DoFetchTopEventDataL( aMessage );

            break;

            }

        case NRequest::ECtxSsFetchTopEventReqId:

            {

            DoFetchTopEventReqIdL( aMessage );

            break;

            }

        case NRequest::ECtxSsDropTopEvent:

            {

            DoDropTopEventL( aMessage );

            break;

            }

        //Synchronous context data access

        case NRequest::ECtxSsPrepareContextFeatures:

            {

            DoPrepareContextFeaturesL( aMessage );

            break;

            }

        case NRequest::ECtxSsGetPreparedData:

            {

            DoGetPreparedDataL( aMessage );

            break;

            }

        default:

            {

            //Unknown request type

            //Nothing to do here.

            }

        }

    }

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

// CXIMPContextSession::NewEventAvailable()

// From MXIMPEventQueueObserver

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

//

void CXIMPContextSession::NewEventAvailable()

    {

    if( iEventListenScout )

        {

        iEventListenScout->Complete( KErrNone );

        delete iEventListenScout;

        iEventListenScout = NULL;

        }

    }

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

// CXIMPContextSession::DoQueueOperationL()

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

//

void CXIMPContextSession::DoQueueOperationL(

    MXIMPSrvMessage& aMessage )

    {

    const TInt operationType = aMessage.Int( MXIMPSrvMessage::Ep0 );

    TPckgBuf< TXIMPRequestId > reqIdBuf;

    // We can take ready unbind from context if it exists.

    CXIMPOperationBase* operation = NULL;

    if( operationType == NXIMPOps::EXIMPUnbindContext )

        {

        operation = iClientData->GetCachedUnbind();

        // ownership transferred

        }

    if( operation )

        {

        // found an unbind, so put it to the queue to be processed

        CleanupStack::PushL( operation );

        iClientData->AppendToOpQueueL( operation );

        reqIdBuf() = operation->RequestId();

        CleanupStack::Pop( operation );

        }

    else

        {

        const TInt pckSize = aMessage.GetDesLengthL( MXIMPSrvMessage::Ep1 );

        HBufC8* paramPck = HBufC8::NewLC( pckSize );

        TPtr8 paramPckPtr = paramPck->Des();

        aMessage.ReadL( MXIMPSrvMessage::Ep1, paramPckPtr );

        reqIdBuf() = iClientData->AddNewOperationL( operationType,

                *paramPck );

        CleanupStack::PopAndDestroy( paramPck );

        }

    aMessage.WriteL( MXIMPSrvMessage::Ep2, reqIdBuf );

    aMessage.Complete( KErrNone );

    }

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

// CXIMPContextSession::DoInstallEventFilterL()

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

//

void CXIMPContextSession::DoInstallEventFilterL(

    MXIMPSrvMessage& aMessage )

    {

    const TInt pckSize = aMessage.GetDesLengthL( MXIMPSrvMessage::Ep0 );

    HBufC8* filterPck = HBufC8::NewLC( pckSize );

    TPtr8 filterPckPtr( filterPck->Des() );

    aMessage.ReadL( MXIMPSrvMessage::Ep0, filterPckPtr );

    CXIMPContextEventFilter* newFilter = CXIMPContextEventFilter::NewLC();

    TXIMPObjectPacker< CXIMPContextEventFilter >::UnPackL( *newFilter,

                                                                   *filterPck );

    iClientData->EventQueue().SetEventFilter( *newFilter );

    CleanupStack::Pop( newFilter );

    CleanupStack::PopAndDestroy( filterPck );

    aMessage.Complete( KErrNone );

    }

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

// CXIMPContextSession::DoSetEventListenScoutL()

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

//

void CXIMPContextSession::DoSetEventListenScoutL(

    MXIMPSrvMessage& aMessage )

    {

    __ASSERT_ALWAYS( !iEventListenScout,

                     aMessage.PanicClientAndLeaveL(

                     NXIMPPanic::EOnSrvAlreadyListeningEvents ) );

    iClientData->EventQueue().StartConsuming( *this );

    //If there is already a events in que,

    //signal client right a way

    if( iClientData->EventQueue().HasElements() )

        {

        aMessage.Complete( KErrNone );

        }

    else

        {

        aMessage.PlaceOwnershipHere( iEventListenScout );

        }

    }

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

// CXIMPContextSession::DoCancelEventListenScout()

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

//

void CXIMPContextSession::DoCancelEventListenScout(

    MXIMPSrvMessage& aMessage )

    {

    if( iEventListenScout )

        {

        iEventListenScout->Complete( KErrCancel );

        delete iEventListenScout;

        iEventListenScout = NULL;

        }

    iClientData->EventQueue().StopConsuming();

    aMessage.Complete( KErrNone );

    }

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

// CXIMPContextSession::DoFetchTopEventDataSizeL()

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

//

void CXIMPContextSession::DoFetchTopEventDataSizeL(

    MXIMPSrvMessage&  aMessage )

    {

    iClientData->EventQueue().SelectTopEventIfNeededL();

    aMessage.Complete( iClientData->EventQueue().TopEventDataL().Size() );

    }

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

// CXIMPContextSession::DoFetchTopEventDataL()

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

//

void CXIMPContextSession::DoFetchTopEventDataL(

    MXIMPSrvMessage& aMessage )

    {

    iClientData->EventQueue().SelectTopEventIfNeededL();

    aMessage.WriteL( MXIMPSrvMessage::Ep0, iClientData->EventQueue().TopEventDataL() );

    aMessage.Complete( KErrNone );

    }

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

// CXIMPContextSession::DoFetchTopEventReqIdL()

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

//

void CXIMPContextSession::DoFetchTopEventReqIdL(

    MXIMPSrvMessage& aMessage )

    {

    TPckgBuf< TXIMPRequestId > reqIdBuf;

    iClientData->EventQueue().SelectTopEventIfNeededL();

    reqIdBuf() = iClientData->EventQueue().TopEventReqIdL();

    aMessage.WriteL( MXIMPSrvMessage::Ep0, reqIdBuf );

    aMessage.Complete( KErrNone );

    }

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

// CXIMPContextSession::DoDropTopEventL()

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

//

void CXIMPContextSession::DoDropTopEventL(

    MXIMPSrvMessage& aMessage )

    {

    iClientData->EventQueue().DropTopEvent();

    aMessage.Complete( KErrNone );

    }

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

// CXIMPContextSession::DoPrepareContextFeaturesL()

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

//

void CXIMPContextSession::DoPrepareContextFeaturesL(

    MXIMPSrvMessage& aMessage )

    {

    __ASSERT_ALWAYS( !iPreparedData,

                     aMessage.PanicClientAndLeaveL(

                     NXIMPPanic::EOnSrvAlreadyHavingPrepearedData ) );

    CXIMPFeatureInfoImp* feats = iClientData->FeaturesForSessionLC();

    iPreparedData = TXIMPObjectPacker< CXIMPFeatureInfoImp >::PackL( *feats );

    CleanupStack::PopAndDestroy( feats );

    aMessage.Complete( iPreparedData->Size() );

    }

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

// CXIMPContextSession::DoGetPreparedDataL()

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

//

void CXIMPContextSession::DoGetPreparedDataL(

    MXIMPSrvMessage& aMessage )

    {

    //Release the prepared data from member variable

    //Buffer gets cleaned even the copying to client side fails

    HBufC8* tmpBuf = iPreparedData;

    iPreparedData = NULL;

    CleanupStack::PushL( tmpBuf );

    //Assert that there is a data to copy to client

    __ASSERT_ALWAYS( tmpBuf,

                     aMessage.PanicClientAndLeaveL(

                     NXIMPPanic::EOnSrvNoPrepearedDataToCopy ) );

    aMessage.WriteL( MXIMPSrvMessage::Ep0, *tmpBuf );

    CleanupStack::PopAndDestroy( tmpBuf );

    aMessage.Complete( KErrNone );

    }

// End of file